juplo.de Git - demos/kafka/wordcount/blob - src/test/java/de/juplo/kafka/wordcount/query/TestData.java

   1 package de.juplo.kafka.wordcount.query;
   2
   3 import de.juplo.kafka.wordcount.top10.TestEntry;
   4 import de.juplo.kafka.wordcount.top10.TestRanking;
   5 import de.juplo.kafka.wordcount.users.TestUserData;
   6 import org.apache.kafka.streams.KeyValue;
   7
   8 import java.util.Arrays;
   9 import java.util.function.Function;
  10 import java.util.stream.Stream;
  11
  12 import static org.assertj.core.api.Assertions.assertThat;
  13
  14
  15 class TestData
  16 {
  17         static final String PETER = "peter";
  18         static final String KLAUS = "klaus";
  19
  20         static final Stream<KeyValue<String, TestRanking>> getTop10Messages()
  21         {
  22                 return Stream.of(TOP10_MESSAGES);
  23         }
  24
  25         static final Stream<KeyValue<String, TestUserData>> getUsersMessages()
  26         {
  27                 return Stream.of(USERS_MESSAGES);
  28         }
  29
  30         static void assertExpectedState(Function<String, UserRanking> function)
  31         {
  32                 assertRankingEqualsRankingFromLastMessage(PETER, function.apply(PETER));
  33                 assertRankingEqualsRankingFromLastMessage(KLAUS, function.apply(KLAUS));
  34         }
  35
  36         private static void assertRankingEqualsRankingFromLastMessage(String user, UserRanking rankingJson)
  37         {
  38                 assertThat(rankingJson).isEqualTo(getLastMessageFor(user));
  39         }
  40
  41         private static UserRanking getLastMessageFor(String user)
  42         {
  43                 return getTop10Messages()
  44                                 .filter(kv -> kv.key.equals(user))
  45                                 .map(kv -> kv.value)
  46                                 .map(testRanking -> userRankingFor(user, testRanking))
  47                                 .reduce(null, (left, right) -> right);
  48         }
  49
  50         private static UserRanking userRankingFor(String user, TestRanking testRanking)
  51         {
  52                 TestUserData testUserData = getUsersMessages()
  53                                 .filter(kv -> kv.key.equals(user))
  54                                 .map(kv -> kv.value)
  55                                 .reduce(null, (left, right) -> right);
  56
  57                 Entry[] entries = Arrays
  58                                 .stream(testRanking.getEntries())
  59                                 .map(testEntry -> entryOf(testEntry))
  60                                 .toArray(size -> new Entry[size]);
  61
  62                 return UserRanking.of(
  63                                 testUserData.getFirstName(),
  64                                 testUserData.getLastName(),
  65                                 entries);
  66         }
  67
  68         private static Entry entryOf(TestEntry testEntry)
  69         {
  70                 Entry entry = new Entry();
  71                 entry.setWord(testEntry.getWord());
  72                 entry.setCount(testEntry.getCount());
  73                 return entry;
  74         }
  75
  76         private static KeyValue<String, TestRanking>[] TOP10_MESSAGES = new KeyValue[]
  77         {
  78                         KeyValue.pair( // 0
  79                                         PETER,
  80                                         TestRanking.of(
  81                                                         TestEntry.of("Hallo", 1l))),
  82                         KeyValue.pair( // 1
  83                                         KLAUS,
  84                                         TestRanking.of(
  85                                                         TestEntry.of("Müsch", 1l))),
  86                         KeyValue.pair( // 2
  87                                         PETER,
  88                                         TestRanking.of(
  89                                                         TestEntry.of("Hallo", 1l),
  90                                                         TestEntry.of("Welt", 1l))),
  91                         KeyValue.pair( // 3
  92                                         KLAUS,
  93                                         TestRanking.of(
  94                                                         TestEntry.of("Müsch", 2l))),
  95                         KeyValue.pair( // 4
  96                                         KLAUS,
  97                                         TestRanking.of(
  98                                                         TestEntry.of("Müsch", 2l),
  99                                                         TestEntry.of("s", 1l))),
 100                         KeyValue.pair( // 5
 101                                         PETER,
 102                                         TestRanking.of(
 103                                                         TestEntry.of("Hallo", 1l),
 104                                                         TestEntry.of("Welt", 1l),
 105                                                         TestEntry.of("Boäh", 1l))),
 106                         KeyValue.pair( // 6
 107                                         PETER,
 108                                         TestRanking.of(
 109                                                         TestEntry.of("Welt", 2l),
 110                                                         TestEntry.of("Hallo", 1l),
 111                                                         TestEntry.of("Boäh", 1l))),
 112                         KeyValue.pair( // 7
 113                                         PETER,
 114                                         TestRanking.of(
 115                                                         TestEntry.of("Welt", 2l),
 116                                                         TestEntry.of("Boäh", 2l),
 117                                                         TestEntry.of("Hallo", 1l))),
 118                         KeyValue.pair( // 8
 119                                         KLAUS,
 120                                         TestRanking.of(
 121                                                         TestEntry.of("Müsch", 2l),
 122                                                         TestEntry.of("s", 2l))),
 123                         KeyValue.pair( // 9
 124                                         PETER,
 125                                         TestRanking.of(
 126                                                         TestEntry.of("Boäh", 3l),
 127                                                         TestEntry.of("Welt", 2l),
 128                                                         TestEntry.of("Hallo", 1l))),
 129                         KeyValue.pair( // 10
 130                                         KLAUS,
 131                                         TestRanking.of(
 132                                                         TestEntry.of("s", 3l),
 133                                                         TestEntry.of("Müsch", 2l))),
 134         };
 135
 136         private static KeyValue<String, TestUserData>[] USERS_MESSAGES = new KeyValue[]
 137         {
 138                         KeyValue.pair(
 139                                         PETER,
 140                                         TestUserData.of(PETER, "Peter", "Pan", TestUserData.Sex.MALE)),
 141                         KeyValue.pair(
 142                                         KLAUS,
 143                                         TestUserData.of(KLAUS, "Klaus", "Klüse", TestUserData.Sex.OTHER)),
 144         };
 145 }