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

   1 package de.juplo.kafka.wordcount.top10;
   2
   3 import de.juplo.kafka.wordcount.counter.TestCounter;
   4 import de.juplo.kafka.wordcount.counter.TestWord;
   5 import de.juplo.kafka.wordcount.query.TestEntry;
   6 import de.juplo.kafka.wordcount.query.TestRanking;
   7 import de.juplo.kafka.wordcount.query.TestUser;
   8 import org.apache.kafka.streams.KeyValue;
   9 import org.apache.kafka.streams.state.ReadOnlyKeyValueStore;
  10 import org.springframework.util.LinkedMultiValueMap;
  11 import org.springframework.util.MultiValueMap;
  12
  13 import java.util.Arrays;
  14 import java.util.stream.Stream;
  15
  16 import static org.assertj.core.api.Assertions.assertThat;
  17
  18
  19 class TestData
  20 {
  21         static final TestUser PETER = TestUser.of("peter");
  22         static final TestUser KLAUS = TestUser.of("klaus");
  23
  24         static final KeyValue<TestWord, TestCounter>[] INPUT_MESSAGES = new KeyValue[]
  25         {
  26                         new KeyValue<>(
  27                                         TestWord.of(PETER.getUser(),"Hallo"),
  28                                         TestCounter.of(PETER.getUser(),"Hallo",1)),
  29                         new KeyValue<>(
  30                                         TestWord.of(KLAUS.getUser(),"Müsch"),
  31                                         TestCounter.of(KLAUS.getUser(),"Müsch",1)),
  32                         new KeyValue<>(
  33                                         TestWord.of(PETER.getUser(),"Welt"),
  34                                         TestCounter.of(PETER.getUser(),"Welt",1)),
  35                         new KeyValue<>(
  36                                         TestWord.of(KLAUS.getUser(),"Müsch"),
  37                                         TestCounter.of(KLAUS.getUser(),"Müsch",2)),
  38                         new KeyValue<>(
  39                                         TestWord.of(KLAUS.getUser(),"s"),
  40                                         TestCounter.of(KLAUS.getUser(),"s",1)),
  41                         new KeyValue<>(
  42                                         TestWord.of(PETER.getUser(),"Boäh"),
  43                                         TestCounter.of(PETER.getUser(),"Boäh",1)),
  44                         new KeyValue<>(
  45                                         TestWord.of(PETER.getUser(),"Welt"),
  46                                         TestCounter.of(PETER.getUser(),"Welt",2)),
  47                         new KeyValue<>(
  48                                         TestWord.of(PETER.getUser(),"Boäh"),
  49                                         TestCounter.of(PETER.getUser(),"Boäh",2)),
  50                         new KeyValue<>(
  51                                         TestWord.of(KLAUS.getUser(),"s"),
  52                                         TestCounter.of(KLAUS.getUser(),"s",2)),
  53                         new KeyValue<>(
  54                                         TestWord.of(PETER.getUser(),"Boäh"),
  55                                         TestCounter.of(PETER.getUser(),"Boäh",3)),
  56                         new KeyValue<>(
  57                                         TestWord.of(KLAUS.getUser(),"s"),
  58                                         TestCounter.of(KLAUS.getUser(),"s",3)),
  59         };
  60
  61         static void assertExpectedMessages(MultiValueMap<TestUser, TestRanking> receivedMessages)
  62         {
  63                 expectedMessages().forEach(
  64                                 (user, rankings) ->
  65                                                 assertThat(receivedMessages.get(user))
  66                                                                 .containsExactlyElementsOf(rankings));
  67         }
  68
  69         static void assertExpectedState(ReadOnlyKeyValueStore<User, Ranking> store)
  70         {
  71                 assertRankingEqualsRankingFromLastMessage(PETER, store.get(userOf(PETER)));
  72                 assertRankingEqualsRankingFromLastMessage(KLAUS, store.get(userOf(KLAUS)));
  73         }
  74
  75         static User userOf(TestUser user)
  76         {
  77                 return User.of(user.getUser());
  78         }
  79
  80         static void assertExpectedNumberOfMessagesForUsers(MultiValueMap<TestUser, TestRanking> receivedMessages)
  81         {
  82                 assertThat(countMessagesForUser(PETER, receivedMessages));
  83                 assertThat(countMessagesForUser(KLAUS, receivedMessages));
  84         }
  85
  86         static int countMessagesForUser(TestUser user, MultiValueMap<TestUser, TestRanking> messagesForUsers)
  87         {
  88                 return messagesForUsers.get(user).size();
  89         }
  90
  91
  92         static void assertExpectedLastMessagesForUsers(MultiValueMap<TestUser, TestRanking> receivedMessages)
  93         {
  94                 assertRankingEqualsRankingFromLastMessage(PETER, getLastMessageFor(PETER, receivedMessages));
  95                 assertRankingEqualsRankingFromLastMessage(KLAUS, getLastMessageFor(KLAUS, receivedMessages));
  96         }
  97
  98         static void assertRankingEqualsRankingFromLastMessage(TestUser user, Ranking ranking)
  99         {
 100                 TestRanking testRanking = TestRanking.of(testEntriesOf(ranking.getEntries()));
 101                 assertRankingEqualsRankingFromLastMessage(user, testRanking);
 102         }
 103
 104         static TestEntry[] testEntriesOf(Entry... entries)
 105         {
 106                 return Arrays
 107                                 .stream(entries)
 108                                 .map(entry -> TestEntry.of(
 109                                                 entry.getWord(),
 110                                                 entry.getCounter() == null
 111                                                                 ? -1l
 112                                                                 : entry.getCounter()))
 113                                 .toArray(size -> new TestEntry[size]);
 114         }
 115
 116         static void assertRankingEqualsRankingFromLastMessage(TestUser user, TestRanking ranking)
 117         {
 118                 assertThat(ranking).isEqualTo(getLastMessageFor(user));
 119         }
 120
 121         static TestRanking getLastMessageFor(TestUser user)
 122         {
 123                 return getLastMessageFor(user, expectedMessages());
 124         }
 125
 126         static TestRanking getLastMessageFor(TestUser user, MultiValueMap<TestUser, TestRanking> messagesForUsers)
 127         {
 128                 return messagesForUsers
 129                                 .get(user)
 130                                 .stream()
 131                                 .reduce(null, (left, right) -> right);
 132         }
 133
 134         static KeyValue<TestUser, TestRanking>[] EXPECTED_MESSAGES = new KeyValue[]
 135         {
 136                         KeyValue.pair( // 0
 137                                         PETER,
 138                                         TestRanking.of(
 139                                                         TestEntry.of("Hallo", 1l))),
 140                         KeyValue.pair( // 1
 141                                         KLAUS,
 142                                         TestRanking.of(
 143                                                         TestEntry.of("Müsch", 1l))),
 144                         KeyValue.pair( // 2
 145                                         PETER,
 146                                         TestRanking.of(
 147                                                         TestEntry.of("Hallo", 1l),
 148                                                         TestEntry.of("Welt", 1l))),
 149                         KeyValue.pair( // 3
 150                                         KLAUS,
 151                                         TestRanking.of(
 152                                                         TestEntry.of("Müsch", 2l))),
 153                         KeyValue.pair( // 4
 154                                         KLAUS,
 155                                         TestRanking.of(
 156                                                         TestEntry.of("Müsch", 2l),
 157                                                         TestEntry.of("s", 1l))),
 158                         KeyValue.pair( // 5
 159                                         PETER,
 160                                         TestRanking.of(
 161                                                         TestEntry.of("Hallo", 1l),
 162                                                         TestEntry.of("Welt", 1l),
 163                                                         TestEntry.of("Boäh", 1l))),
 164                         KeyValue.pair( // 6
 165                                         PETER,
 166                                         TestRanking.of(
 167                                                         TestEntry.of("Welt", 2l),
 168                                                         TestEntry.of("Hallo", 1l),
 169                                                         TestEntry.of("Boäh", 1l))),
 170                         KeyValue.pair( // 7
 171                                         PETER,
 172                                         TestRanking.of(
 173                                                         TestEntry.of("Welt", 2l),
 174                                                         TestEntry.of("Boäh", 2l),
 175                                                         TestEntry.of("Hallo", 1l))),
 176                         KeyValue.pair( // 8
 177                                         KLAUS,
 178                                         TestRanking.of(
 179                                                         TestEntry.of("Müsch", 2l),
 180                                                         TestEntry.of("s", 2l))),
 181                         KeyValue.pair( // 9
 182                                         PETER,
 183                                         TestRanking.of(
 184                                                         TestEntry.of("Boäh", 3l),
 185                                                         TestEntry.of("Welt", 2l),
 186                                                         TestEntry.of("Hallo", 1l))),
 187                         KeyValue.pair( // 10
 188                                         KLAUS,
 189                                         TestRanking.of(
 190                                                         TestEntry.of("s", 3l),
 191                                                         TestEntry.of("Müsch", 2l))),
 192         };
 193
 194         static MultiValueMap<TestUser, TestRanking> expectedMessages()
 195         {
 196                 MultiValueMap<TestUser, TestRanking> expectedMessages = new LinkedMultiValueMap<>();
 197                 Stream
 198                                 .of(EXPECTED_MESSAGES)
 199                                 .forEach(keyValue -> expectedMessages.add(keyValue.key, keyValue.value));
 200                 return expectedMessages;
 201         }
 202 }