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.common.header.Header;
   6 import org.apache.kafka.common.header.Headers;
   7 import org.apache.kafka.streams.KeyValue;
   8 import org.springframework.util.LinkedMultiValueMap;
   9 import org.springframework.util.MultiValueMap;
  10
  11 import java.util.Map;
  12 import java.util.Properties;
  13 import java.util.stream.Collectors;
  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 KeyValue<TestWord, TestCounter>[] INPUT_MESSAGES = new KeyValue[]
  22         {
  23                         new KeyValue<>(
  24                                         TestWord.of("peter","Hallo"),
  25                                         TestCounter.of("peter","Hallo",1)),
  26                         new KeyValue<>(
  27                                         TestWord.of("klaus","Müsch"),
  28                                         TestCounter.of("klaus","Müsch",1)),
  29                         new KeyValue<>(
  30                                         TestWord.of("peter","Welt"),
  31                                         TestCounter.of("peter","Welt",1)),
  32                         new KeyValue<>(
  33                                         TestWord.of("klaus","Müsch"),
  34                                         TestCounter.of("klaus","Müsch",2)),
  35                         new KeyValue<>(
  36                                         TestWord.of("klaus","s"),
  37                                         TestCounter.of("klaus","s",1)),
  38                         new KeyValue<>(
  39                                         TestWord.of("peter","Boäh"),
  40                                         TestCounter.of("peter","Boäh",1)),
  41                         new KeyValue<>(
  42                                         TestWord.of("peter","Welt"),
  43                                         TestCounter.of("peter","Welt",2)),
  44                         new KeyValue<>(
  45                                         TestWord.of("peter","Boäh"),
  46                                         TestCounter.of("peter","Boäh",2)),
  47                         new KeyValue<>(
  48                                         TestWord.of("klaus","s"),
  49                                         TestCounter.of("klaus","s",2)),
  50                         new KeyValue<>(
  51                                         TestWord.of("peter","Boäh"),
  52                                         TestCounter.of("peter","Boäh",3)),
  53                         new KeyValue<>(
  54                                         TestWord.of("klaus","s"),
  55                                         TestCounter.of("klaus","s",3)),
  56         };
  57
  58         static void assertExpectedMessages(MultiValueMap<User, Ranking> receivedMessages)
  59         {
  60                 expectedMessages().forEach(
  61                                 (user, rankings) ->
  62                                                 assertThat(receivedMessages.get(user))
  63                                                                 .containsExactlyElementsOf(rankings));
  64         }
  65
  66         static KeyValue<User, Ranking>[] EXPECTED_MESSAGES = new KeyValue[]
  67         {
  68                         KeyValue.pair( // 0
  69                                         User.of("peter"),
  70                                         Ranking.of(
  71                                                         Entry.of("Hallo", 1l))),
  72                         KeyValue.pair( // 1
  73                                         User.of("klaus"),
  74                                         Ranking.of(
  75                                                         Entry.of("Müsch", 1l))),
  76                         KeyValue.pair( // 2
  77                                         User.of("peter"),
  78                                         Ranking.of(
  79                                                         Entry.of("Hallo", 1l),
  80                                                         Entry.of("Welt", 1l))),
  81                         KeyValue.pair( // 3
  82                                         User.of("klaus"),
  83                                         Ranking.of(
  84                                                         Entry.of("Müsch", 2l))),
  85                         KeyValue.pair( // 4
  86                                         User.of("klaus"),
  87                                         Ranking.of(
  88                                                         Entry.of("Müsch", 2l),
  89                                                         Entry.of("s", 1l))),
  90                         KeyValue.pair( // 5
  91                                         User.of("peter"),
  92                                         Ranking.of(
  93                                                         Entry.of("Hallo", 1l),
  94                                                         Entry.of("Welt", 1l),
  95                                                         Entry.of("Boäh", 1l))),
  96                         KeyValue.pair( // 6
  97                                         User.of("peter"),
  98                                         Ranking.of(
  99                                                         Entry.of("Welt", 2l),
 100                                                         Entry.of("Hallo", 1l),
 101                                                         Entry.of("Boäh", 1l))),
 102                         KeyValue.pair( // 7
 103                                         User.of("peter"),
 104                                         Ranking.of(
 105                                                         Entry.of("Welt", 2l),
 106                                                         Entry.of("Boäh", 2l),
 107                                                         Entry.of("Hallo", 1l))),
 108                         KeyValue.pair( // 8
 109                                         User.of("klaus"),
 110                                         Ranking.of(
 111                                                         Entry.of("Müsch", 2l),
 112                                                         Entry.of("s", 2l))),
 113                         KeyValue.pair( // 9
 114                                         User.of("peter"),
 115                                         Ranking.of(
 116                                                         Entry.of("Boäh", 3l),
 117                                                         Entry.of("Welt", 2l),
 118                                                         Entry.of("Hallo", 1l))),
 119                         KeyValue.pair( // 10
 120                                         User.of("klaus"),
 121                                         Ranking.of(
 122                                                         Entry.of("s", 3l),
 123                                                         Entry.of("Müsch", 2l))),
 124         };
 125
 126         static MultiValueMap<User, Ranking> expectedMessages()
 127         {
 128                 MultiValueMap<User, Ranking> expectedMessages = new LinkedMultiValueMap<>();
 129                 Stream
 130                                 .of(EXPECTED_MESSAGES)
 131                                 .forEach(keyValue -> expectedMessages.add(keyValue.key, keyValue.value));
 132                 return expectedMessages;
 133         }
 134
 135         static Map<String, Object> convertToMap(Properties properties)
 136         {
 137                 return properties
 138                                 .entrySet()
 139                                 .stream()
 140                                 .collect(
 141                                                 Collectors.toMap(
 142                                                                 entry -> (String)entry.getKey(),
 143                                                                 entry -> entry.getValue()
 144                                                 ));
 145         }
 146
 147         static String parseHeader(Headers headers, String key)
 148         {
 149                 Header header = headers.lastHeader(key);
 150                 if (header == null)
 151                 {
 152                         return key + "=null";
 153                 }
 154                 else
 155                 {
 156                         return key + "=" + new String(header.value());
 157                 }
 158         }
 159 }