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