X-Git-Url: https://juplo.de/gitweb/?a=blobdiff_plain;f=src%2Ftest%2Fjava%2Fde%2Fjuplo%2Fkafka%2Fwordcount%2Ftop10%2FTestData.java;h=7a3a27edddb2722dae8dbf4f53d59c9ebcddd58f;hb=refs%2Fheads%2Ftop10;hp=f4e557c6a03406a88b018325d0121b9af165d701;hpb=d1ac99074b22f357152644d4593b234540d1c952;p=demos%2Fkafka%2Fwordcount diff --git a/src/test/java/de/juplo/kafka/wordcount/top10/TestData.java b/src/test/java/de/juplo/kafka/wordcount/top10/TestData.java index f4e557c..069f49a 100644 --- a/src/test/java/de/juplo/kafka/wordcount/top10/TestData.java +++ b/src/test/java/de/juplo/kafka/wordcount/top10/TestData.java @@ -2,13 +2,15 @@ package de.juplo.kafka.wordcount.top10; import de.juplo.kafka.wordcount.counter.TestCounter; import de.juplo.kafka.wordcount.counter.TestWord; -import org.apache.kafka.common.header.Header; -import org.apache.kafka.common.header.Headers; +import de.juplo.kafka.wordcount.query.TestEntry; +import de.juplo.kafka.wordcount.query.TestRanking; +import de.juplo.kafka.wordcount.query.TestStats; import org.apache.kafka.streams.KeyValue; import org.apache.kafka.streams.state.ReadOnlyKeyValueStore; import org.springframework.util.LinkedMultiValueMap; import org.springframework.util.MultiValueMap; +import java.util.Arrays; import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThat; @@ -16,175 +18,196 @@ import static org.assertj.core.api.Assertions.assertThat; class TestData { - static final User PETER = User.of("peter"); - static final User KLAUS = User.of("klaus"); + static final String TYPE_COUNTER = "COUNTER"; - static final KeyValue[] INPUT_MESSAGES = new KeyValue[] + static final TestStats PETER = TestStats.of(StatsType.COUNTER.name(), "peter"); + static final TestStats KLAUS = TestStats.of(StatsType.COUNTER.name(), "klaus"); + + static final Stream> getInputMessages() + { + return Stream.of(INPUT_MESSAGES); + } + + private static final KeyValue[] INPUT_MESSAGES = new KeyValue[] { new KeyValue<>( - TestWord.of(PETER.getUser(),"Hallo"), - TestCounter.of(PETER.getUser(),"Hallo",1)), + TestWord.of(TYPE_COUNTER, PETER.getChannel(),"Hallo"), + TestCounter.of("Hallo",1)), new KeyValue<>( - TestWord.of(KLAUS.getUser(),"Müsch"), - TestCounter.of(KLAUS.getUser(),"Müsch",1)), + TestWord.of(TYPE_COUNTER, KLAUS.getChannel(),"Müsch"), + TestCounter.of("Müsch",1)), new KeyValue<>( - TestWord.of(PETER.getUser(),"Welt"), - TestCounter.of(PETER.getUser(),"Welt",1)), + TestWord.of(TYPE_COUNTER, PETER.getChannel(),"Welt"), + TestCounter.of("Welt",1)), new KeyValue<>( - TestWord.of(KLAUS.getUser(),"Müsch"), - TestCounter.of(KLAUS.getUser(),"Müsch",2)), + TestWord.of(TYPE_COUNTER, KLAUS.getChannel(),"Müsch"), + TestCounter.of("Müsch",2)), new KeyValue<>( - TestWord.of(KLAUS.getUser(),"s"), - TestCounter.of(KLAUS.getUser(),"s",1)), + TestWord.of(TYPE_COUNTER, KLAUS.getChannel(),"s"), + TestCounter.of("s",1)), new KeyValue<>( - TestWord.of(PETER.getUser(),"Boäh"), - TestCounter.of(PETER.getUser(),"Boäh",1)), + TestWord.of(TYPE_COUNTER, PETER.getChannel(),"Boäh"), + TestCounter.of("Boäh",1)), new KeyValue<>( - TestWord.of(PETER.getUser(),"Welt"), - TestCounter.of(PETER.getUser(),"Welt",2)), + TestWord.of(TYPE_COUNTER, PETER.getChannel(),"Welt"), + TestCounter.of("Welt",2)), new KeyValue<>( - TestWord.of(PETER.getUser(),"Boäh"), - TestCounter.of(PETER.getUser(),"Boäh",2)), + TestWord.of(TYPE_COUNTER, PETER.getChannel(),"Boäh"), + TestCounter.of("Boäh",2)), new KeyValue<>( - TestWord.of(KLAUS.getUser(),"s"), - TestCounter.of(KLAUS.getUser(),"s",2)), + TestWord.of(TYPE_COUNTER, KLAUS.getChannel(),"s"), + TestCounter.of("s",2)), new KeyValue<>( - TestWord.of(PETER.getUser(),"Boäh"), - TestCounter.of(PETER.getUser(),"Boäh",3)), + TestWord.of(TYPE_COUNTER, PETER.getChannel(),"Boäh"), + TestCounter.of("Boäh",3)), new KeyValue<>( - TestWord.of(KLAUS.getUser(),"s"), - TestCounter.of(KLAUS.getUser(),"s",3)), + TestWord.of(TYPE_COUNTER, KLAUS.getChannel(),"s"), + TestCounter.of("s",3)), }; - static void assertExpectedMessages(MultiValueMap receivedMessages) + static void assertExpectedMessages(MultiValueMap receivedMessages) { expectedMessages().forEach( - (user, rankings) -> - assertThat(receivedMessages.get(user)) + (stats, rankings) -> + assertThat(receivedMessages.get(stats)) .containsExactlyElementsOf(rankings)); } - static void assertExpectedState(ReadOnlyKeyValueStore store) + static void assertExpectedState(ReadOnlyKeyValueStore store) { - assertRankingEqualsRankingFromLastMessage(PETER, store.get(PETER)); - assertRankingEqualsRankingFromLastMessage(KLAUS, store.get(KLAUS)); + assertRankingEqualsRankingFromLastMessage(PETER, store.get(statsOf(PETER))); + assertRankingEqualsRankingFromLastMessage(KLAUS, store.get(statsOf(KLAUS))); } - static void assertExpectedNumberOfMessagesForUsers(MultiValueMap receivedMessages) + private static Stats statsOf(TestStats stats) { - assertThat(countMessagesForUser(PETER, receivedMessages)); - assertThat(countMessagesForUser(KLAUS, receivedMessages)); + return Stats.of( + StatsType.valueOf(stats.getType()), + stats.getChannel()); } - static int countMessagesForUser(User user, MultiValueMap messagesForUsers) + static void assertExpectedNumberOfMessages(MultiValueMap receivedMessages) { - return messagesForUsers.get(user).size(); + assertThat(countMessages(PETER, receivedMessages)); + assertThat(countMessages(KLAUS, receivedMessages)); } + private static int countMessages(TestStats stats, MultiValueMap messagesFor) + { + return messagesFor.get(stats) == null + ? 0 + : messagesFor.get(stats).size(); + } - static void assertExpectedLastMessagesForUsers(MultiValueMap receivedMessages) + + static void assertExpectedLastMessages(MultiValueMap receivedMessages) { assertRankingEqualsRankingFromLastMessage(PETER, getLastMessageFor(PETER, receivedMessages)); assertRankingEqualsRankingFromLastMessage(KLAUS, getLastMessageFor(KLAUS, receivedMessages)); } - static void assertRankingEqualsRankingFromLastMessage(User user, Ranking ranking) + private static void assertRankingEqualsRankingFromLastMessage(TestStats stats, Ranking ranking) + { + TestRanking testRanking = TestRanking.of(testEntriesOf(ranking.getEntries())); + assertRankingEqualsRankingFromLastMessage(stats, testRanking); + } + + private static TestEntry[] testEntriesOf(Entry... entries) + { + return Arrays + .stream(entries) + .map(entry -> TestEntry.of( + entry.getKey(), + entry.getCounter() == null + ? -1l + : entry.getCounter())) + .toArray(size -> new TestEntry[size]); + } + + private static void assertRankingEqualsRankingFromLastMessage(TestStats stats, TestRanking ranking) { - assertThat(ranking).isEqualTo(getLastMessageFor(user)); + assertThat(ranking).isEqualTo(getLastMessageFor(stats)); } - static Ranking getLastMessageFor(User user) + private static TestRanking getLastMessageFor(TestStats stats) { - return getLastMessageFor(user, expectedMessages()); + return getLastMessageFor(stats, expectedMessages()); } - static Ranking getLastMessageFor(User user, MultiValueMap messagesForUsers) + private static TestRanking getLastMessageFor(TestStats stats, MultiValueMap messagesFor) { - return messagesForUsers - .get(user) + return messagesFor + .get(stats) .stream() .reduce(null, (left, right) -> right); } - static KeyValue[] EXPECTED_MESSAGES = new KeyValue[] + private static KeyValue[] EXPECTED_MESSAGES = new KeyValue[] { KeyValue.pair( // 0 PETER, - Ranking.of( - Entry.of("Hallo", 1l))), + TestRanking.of( + TestEntry.of("Hallo", 1l))), KeyValue.pair( // 1 KLAUS, - Ranking.of( - Entry.of("Müsch", 1l))), + TestRanking.of( + TestEntry.of("Müsch", 1l))), KeyValue.pair( // 2 PETER, - Ranking.of( - Entry.of("Hallo", 1l), - Entry.of("Welt", 1l))), + TestRanking.of( + TestEntry.of("Hallo", 1l), + TestEntry.of("Welt", 1l))), KeyValue.pair( // 3 KLAUS, - Ranking.of( - Entry.of("Müsch", 2l))), + TestRanking.of( + TestEntry.of("Müsch", 2l))), KeyValue.pair( // 4 KLAUS, - Ranking.of( - Entry.of("Müsch", 2l), - Entry.of("s", 1l))), + TestRanking.of( + TestEntry.of("Müsch", 2l), + TestEntry.of("s", 1l))), KeyValue.pair( // 5 PETER, - Ranking.of( - Entry.of("Hallo", 1l), - Entry.of("Welt", 1l), - Entry.of("Boäh", 1l))), + TestRanking.of( + TestEntry.of("Hallo", 1l), + TestEntry.of("Welt", 1l), + TestEntry.of("Boäh", 1l))), KeyValue.pair( // 6 PETER, - Ranking.of( - Entry.of("Welt", 2l), - Entry.of("Hallo", 1l), - Entry.of("Boäh", 1l))), + TestRanking.of( + TestEntry.of("Welt", 2l), + TestEntry.of("Hallo", 1l), + TestEntry.of("Boäh", 1l))), KeyValue.pair( // 7 PETER, - Ranking.of( - Entry.of("Welt", 2l), - Entry.of("Boäh", 2l), - Entry.of("Hallo", 1l))), + TestRanking.of( + TestEntry.of("Welt", 2l), + TestEntry.of("Boäh", 2l), + TestEntry.of("Hallo", 1l))), KeyValue.pair( // 8 KLAUS, - Ranking.of( - Entry.of("Müsch", 2l), - Entry.of("s", 2l))), + TestRanking.of( + TestEntry.of("Müsch", 2l), + TestEntry.of("s", 2l))), KeyValue.pair( // 9 PETER, - Ranking.of( - Entry.of("Boäh", 3l), - Entry.of("Welt", 2l), - Entry.of("Hallo", 1l))), + TestRanking.of( + TestEntry.of("Boäh", 3l), + TestEntry.of("Welt", 2l), + TestEntry.of("Hallo", 1l))), KeyValue.pair( // 10 KLAUS, - Ranking.of( - Entry.of("s", 3l), - Entry.of("Müsch", 2l))), + TestRanking.of( + TestEntry.of("s", 3l), + TestEntry.of("Müsch", 2l))), }; - static MultiValueMap expectedMessages() + private static MultiValueMap expectedMessages() { - MultiValueMap expectedMessages = new LinkedMultiValueMap<>(); + MultiValueMap expectedMessages = new LinkedMultiValueMap<>(); Stream .of(EXPECTED_MESSAGES) .forEach(keyValue -> expectedMessages.add(keyValue.key, keyValue.value)); return expectedMessages; } - - static String parseHeader(Headers headers, String key) - { - Header header = headers.lastHeader(key); - if (header == null) - { - return key + "=null"; - } - else - { - return key + "=" + new String(header.value()); - } - } }