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.top10.TestUser;
   6 import de.juplo.kafka.wordcount.users.TestUserData;
   7 import org.apache.kafka.streams.KeyValue;
   8
   9 import java.util.Arrays;
  10 import java.util.function.Function;
  11 import java.util.stream.Stream;
  12
  13 import static org.assertj.core.api.Assertions.assertThat;
  14
  15
  16 class TestData
  17 {
  18         static final TestUser PETER = TestUser.of("peter");
  19         static final TestUser KLAUS = TestUser.of("klaus");
  20
  21         static final Stream<KeyValue<TestUser, TestRanking>> getTop10Messages()
  22         {
  23                 return Stream.of(TOP10_MESSAGES);
  24         }
  25
  26         static final Stream<KeyValue<String, TestUserData>> getUsersMessages()
  27         {
  28                 return Stream.of(USERS_MESSAGES);
  29         }
  30
  31         static void assertExpectedState(Function<String, UserRanking> function)
  32         {
  33                 assertRankingEqualsRankingFromLastMessage(PETER.getUser(), function.apply(PETER.getUser()));
  34                 assertRankingEqualsRankingFromLastMessage(KLAUS.getUser(), function.apply(KLAUS.getUser()));
  35         }
  36
  37         private static void assertRankingEqualsRankingFromLastMessage(String user, UserRanking rankingJson)
  38         {
  39                 assertThat(rankingJson).isEqualTo(getLastMessageFor(user));
  40         }
  41
  42         private static UserRanking getLastMessageFor(String user)
  43         {
  44                 return getTop10Messages()
  45                                 .filter(kv -> kv.key.getUser().equals(user))
  46                                 .map(kv -> kv.value)
  47                                 .map(testRanking -> userRankingFor(user, testRanking))
  48                                 .reduce(null, (left, right) -> right);
  49         }
  50
  51         private static UserRanking userRankingFor(String user, TestRanking testRanking)
  52         {
  53                 TestUserData testUserData = getUsersMessages()
  54                                 .filter(kv -> kv.key.equals(user))
  55                                 .map(kv -> kv.value)
  56                                 .reduce(null, (left, right) -> right);
  57
  58                 Entry[] entries = Arrays
  59                                 .stream(testRanking.getEntries())
  60                                 .map(testEntry -> entryOf(testEntry))
  61                                 .toArray(size -> new Entry[size]);
  62
  63                 return UserRanking.of(
  64                                 testUserData.getFirstName(),
  65                                 testUserData.getLastName(),
  66                                 entries);
  67         }
  68
  69         private static Entry entryOf(TestEntry testEntry)
  70         {
  71                 Entry entry = new Entry();
  72                 entry.setWord(testEntry.getWord());
  73                 entry.setCounter(testEntry.getCounter());
  74                 return entry;
  75         }
  76         private static KeyValue<TestUser, 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.getUser(),
 140                                         TestUserData.of(PETER.getUser(), "Peter", "Pan", TestUserData.Sex.MALE)),
 141                         KeyValue.pair(
 142                                         KLAUS.getUser(),
 143                                         TestUserData.of(KLAUS.getUser(), "Klaus", "Klüse", TestUserData.Sex.OTHER)),
 144         };
 145 }