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

   1 package de.juplo.kafka.wordcount.counter;
   2
   3 import org.apache.kafka.common.header.Header;
   4 import org.apache.kafka.common.header.Headers;
   5 import org.apache.kafka.streams.KeyValue;
   6 import org.springframework.util.LinkedMultiValueMap;
   7 import org.springframework.util.MultiValueMap;
   8
   9 import java.util.Map;
  10 import java.util.Properties;
  11 import java.util.stream.Collectors;
  12 import java.util.stream.Stream;
  13
  14 import static org.assertj.core.api.Assertions.assertThat;
  15
  16
  17 class TestData
  18 {
  19         static final Word[] INPUT_MESSAGES = new Word[]
  20         {
  21                         Word.of("peter","Hallo"),
  22                         Word.of("klaus","Müsch"),
  23                         Word.of("peter","Welt"),
  24                         Word.of("klaus","Müsch"),
  25                         Word.of("klaus","s"),
  26                         Word.of("peter","Boäh"),
  27                         Word.of("peter","Welt"),
  28                         Word.of("peter","Boäh"),
  29                         Word.of("klaus","s"),
  30                         Word.of("peter","Boäh"),
  31                         Word.of("klaus","s"),
  32         };
  33
  34         static void assertExpectedMessages(MultiValueMap<Word, WordCounter> receivedMessages)
  35         {
  36                 expectedMessages().forEach(
  37                                 (word, counter) ->
  38                                                 assertThat(receivedMessages.get(word))
  39                                                                 .containsExactlyElementsOf(counter));
  40         }
  41
  42         static final KeyValue<Word, WordCounter>[] EXPECTED_MESSAGES = new KeyValue[]
  43         {
  44                         KeyValue.pair(
  45                                         Word.of("peter","Hallo"),
  46                                         WordCounter.of("peter","Hallo",1)),
  47                         KeyValue.pair(
  48                                         Word.of("klaus","Müsch"),
  49                                         WordCounter.of("klaus","Müsch",1)),
  50                         KeyValue.pair(
  51                                         Word.of("peter","Welt"),
  52                                         WordCounter.of("peter","Welt",1)),
  53                         KeyValue.pair(
  54                                         Word.of("klaus","Müsch"),
  55                                         WordCounter.of("klaus","Müsch",2)),
  56                         KeyValue.pair(
  57                                         Word.of("klaus","s"),
  58                                         WordCounter.of("klaus","s",1)),
  59                         KeyValue.pair(
  60                                         Word.of("peter","Boäh"),
  61                                         WordCounter.of("peter","Boäh",1)),
  62                         KeyValue.pair(
  63                                         Word.of("peter","Welt"),
  64                                         WordCounter.of("peter","Welt",2)),
  65                         KeyValue.pair(
  66                                         Word.of("peter","Boäh"),
  67                                         WordCounter.of("peter","Boäh",2)),
  68                         KeyValue.pair(
  69                                         Word.of("klaus","s"),
  70                                         WordCounter.of("klaus","s",2)),
  71                         KeyValue.pair(
  72                                         Word.of("peter","Boäh"),
  73                                         WordCounter.of("peter","Boäh",3)),
  74                         KeyValue.pair(
  75                                         Word.of("klaus","s"),
  76                                         WordCounter.of("klaus","s",3)),
  77         };
  78
  79         static MultiValueMap<Word, WordCounter> expectedMessages()
  80         {
  81                 MultiValueMap<Word, WordCounter> expectedMessages = new LinkedMultiValueMap<>();
  82                 Stream
  83                                 .of(EXPECTED_MESSAGES)
  84                                 .forEach(keyValue -> expectedMessages.add(keyValue.key, keyValue.value));
  85                 return expectedMessages;
  86         }
  87
  88         static Map<String, Object> convertToMap(Properties properties)
  89         {
  90                 return properties
  91                                 .entrySet()
  92                                 .stream()
  93                                 .collect(
  94                                                 Collectors.toMap(
  95                                                                 entry -> (String)entry.getKey(),
  96                                                                 entry -> entry.getValue()
  97                                                 ));
  98         }
  99
 100         static String parseHeader(Headers headers, String key)
 101         {
 102                 Header header = headers.lastHeader(key);
 103                 if (header == null)
 104                 {
 105                         return key + "=null";
 106                 }
 107                 else
 108                 {
 109                         return key + "=" + new String(header.value());
 110                 }
 111         }
 112 }