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