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 org.apache.kafka.streams.KeyValue;
   6 import org.apache.kafka.streams.state.ReadOnlyKeyValueStore;
   7 import org.springframework.util.LinkedMultiValueMap;
   8 import org.springframework.util.MultiValueMap;
   9
  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 User PETER = User.of("peter");
  18         static final User KLAUS = User.of("klaus");
  19
  20         static final KeyValue<TestWord, TestCounter>[] INPUT_MESSAGES = new KeyValue[]
  21         {
  22                         new KeyValue<>(
  23                                         TestWord.of(PETER.getUser(),"Hallo"),
  24                                         TestCounter.of(PETER.getUser(),"Hallo",1)),
  25                         new KeyValue<>(
  26                                         TestWord.of(KLAUS.getUser(),"Müsch"),
  27                                         TestCounter.of(KLAUS.getUser(),"Müsch",1)),
  28                         new KeyValue<>(
  29                                         TestWord.of(PETER.getUser(),"Welt"),
  30                                         TestCounter.of(PETER.getUser(),"Welt",1)),
  31                         new KeyValue<>(
  32                                         TestWord.of(KLAUS.getUser(),"Müsch"),
  33                                         TestCounter.of(KLAUS.getUser(),"Müsch",2)),
  34                         new KeyValue<>(
  35                                         TestWord.of(KLAUS.getUser(),"s"),
  36                                         TestCounter.of(KLAUS.getUser(),"s",1)),
  37                         new KeyValue<>(
  38                                         TestWord.of(PETER.getUser(),"Boäh"),
  39                                         TestCounter.of(PETER.getUser(),"Boäh",1)),
  40                         new KeyValue<>(
  41                                         TestWord.of(PETER.getUser(),"Welt"),
  42                                         TestCounter.of(PETER.getUser(),"Welt",2)),
  43                         new KeyValue<>(
  44                                         TestWord.of(PETER.getUser(),"Boäh"),
  45                                         TestCounter.of(PETER.getUser(),"Boäh",2)),
  46                         new KeyValue<>(
  47                                         TestWord.of(KLAUS.getUser(),"s"),
  48                                         TestCounter.of(KLAUS.getUser(),"s",2)),
  49                         new KeyValue<>(
  50                                         TestWord.of(PETER.getUser(),"Boäh"),
  51                                         TestCounter.of(PETER.getUser(),"Boäh",3)),
  52                         new KeyValue<>(
  53                                         TestWord.of(KLAUS.getUser(),"s"),
  54                                         TestCounter.of(KLAUS.getUser(),"s",3)),
  55         };
  56
  57         static void assertExpectedMessages(MultiValueMap<User, Ranking> receivedMessages)
  58         {
  59                 expectedMessages().forEach(
  60                                 (user, rankings) ->
  61                                                 assertThat(receivedMessages.get(user))
  62                                                                 .containsExactlyElementsOf(rankings));
  63         }
  64
  65         static void assertExpectedState(ReadOnlyKeyValueStore<User, Ranking> store)
  66         {
  67                 assertRankingEqualsRankingFromLastMessage(PETER, store.get(PETER));
  68                 assertRankingEqualsRankingFromLastMessage(KLAUS, store.get(KLAUS));
  69         }
  70
  71         static void assertExpectedNumberOfMessagesForUsers(MultiValueMap<User, Ranking> receivedMessages)
  72         {
  73                 assertThat(countMessagesForUser(PETER, receivedMessages));
  74                 assertThat(countMessagesForUser(KLAUS, receivedMessages));
  75         }
  76
  77         static int countMessagesForUser(User user, MultiValueMap<User, Ranking> messagesForUsers)
  78         {
  79                 return messagesForUsers.get(user).size();
  80         }
  81
  82
  83         static void assertExpectedLastMessagesForUsers(MultiValueMap<User, Ranking> receivedMessages)
  84         {
  85                 assertRankingEqualsRankingFromLastMessage(PETER, getLastMessageFor(PETER, receivedMessages));
  86                 assertRankingEqualsRankingFromLastMessage(KLAUS, getLastMessageFor(KLAUS, receivedMessages));
  87         }
  88
  89         static void assertRankingEqualsRankingFromLastMessage(User user, Ranking ranking)
  90         {
  91                 assertThat(ranking).isEqualTo(getLastMessageFor(user));
  92         }
  93
  94         static Ranking getLastMessageFor(User user)
  95         {
  96                 return getLastMessageFor(user, expectedMessages());
  97         }
  98
  99         static Ranking getLastMessageFor(User user, MultiValueMap<User, Ranking> messagesForUsers)
 100         {
 101                 return messagesForUsers
 102                                 .get(user)
 103                                 .stream()
 104                                 .reduce(null, (left, right) -> right);
 105         }
 106
 107         static KeyValue<User, Ranking>[] EXPECTED_MESSAGES = new KeyValue[]
 108         {
 109                         KeyValue.pair( // 0
 110                                         PETER,
 111                                         Ranking.of(
 112                                                         Entry.of("Hallo", 1l))),
 113                         KeyValue.pair( // 1
 114                                         KLAUS,
 115                                         Ranking.of(
 116                                                         Entry.of("Müsch", 1l))),
 117                         KeyValue.pair( // 2
 118                                         PETER,
 119                                         Ranking.of(
 120                                                         Entry.of("Hallo", 1l),
 121                                                         Entry.of("Welt", 1l))),
 122                         KeyValue.pair( // 3
 123                                         KLAUS,
 124                                         Ranking.of(
 125                                                         Entry.of("Müsch", 2l))),
 126                         KeyValue.pair( // 4
 127                                         KLAUS,
 128                                         Ranking.of(
 129                                                         Entry.of("Müsch", 2l),
 130                                                         Entry.of("s", 1l))),
 131                         KeyValue.pair( // 5
 132                                         PETER,
 133                                         Ranking.of(
 134                                                         Entry.of("Hallo", 1l),
 135                                                         Entry.of("Welt", 1l),
 136                                                         Entry.of("Boäh", 1l))),
 137                         KeyValue.pair( // 6
 138                                         PETER,
 139                                         Ranking.of(
 140                                                         Entry.of("Welt", 2l),
 141                                                         Entry.of("Hallo", 1l),
 142                                                         Entry.of("Boäh", 1l))),
 143                         KeyValue.pair( // 7
 144                                         PETER,
 145                                         Ranking.of(
 146                                                         Entry.of("Welt", 2l),
 147                                                         Entry.of("Boäh", 2l),
 148                                                         Entry.of("Hallo", 1l))),
 149                         KeyValue.pair( // 8
 150                                         KLAUS,
 151                                         Ranking.of(
 152                                                         Entry.of("Müsch", 2l),
 153                                                         Entry.of("s", 2l))),
 154                         KeyValue.pair( // 9
 155                                         PETER,
 156                                         Ranking.of(
 157                                                         Entry.of("Boäh", 3l),
 158                                                         Entry.of("Welt", 2l),
 159                                                         Entry.of("Hallo", 1l))),
 160                         KeyValue.pair( // 10
 161                                         KLAUS,
 162                                         Ranking.of(
 163                                                         Entry.of("s", 3l),
 164                                                         Entry.of("Müsch", 2l))),
 165         };
 166
 167         static MultiValueMap<User, Ranking> expectedMessages()
 168         {
 169                 MultiValueMap<User, Ranking> expectedMessages = new LinkedMultiValueMap<>();
 170                 Stream
 171                                 .of(EXPECTED_MESSAGES)
 172                                 .forEach(keyValue -> expectedMessages.add(keyValue.key, keyValue.value));
 173                 return expectedMessages;
 174         }
 175 }