Springify: Gemeinsame DLQ für Poison Pills und Fachlogik-Fehler konfiguriert

[demos/kafka/training] / src / test / java / de / juplo / kafka / ApplicationTests.java

diff --git a/src/test/java/de/juplo/kafka/ApplicationTests.java b/src/test/java/de/juplo/kafka/ApplicationTests.java
index 3f6a6a8..43a4f61 100644 (file)
--- a/src/test/java/de/juplo/kafka/ApplicationTests.java
+++ b/src/test/java/de/juplo/kafka/ApplicationTests.java
@@ -6,7 +6,6 @@ import org.apache.kafka.clients.consumer.KafkaConsumer;
 import org.apache.kafka.clients.producer.KafkaProducer;
 import org.apache.kafka.clients.producer.ProducerRecord;
 import org.apache.kafka.common.TopicPartition;
-import org.apache.kafka.common.errors.RecordDeserializationException;
 import org.apache.kafka.common.serialization.*;
 import org.apache.kafka.common.utils.Bytes;
 import org.junit.jupiter.api.*;
@@ -44,10 +43,10 @@ import static org.awaitility.Awaitility.*;
                                EndlessConsumer.class,
                                KafkaAutoConfiguration.class,
                                ApplicationTests.Configuration.class })
-@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
 @TestPropertySource(
                properties = {
                                "spring.kafka.consumer.bootstrap-servers=${spring.embedded.kafka.brokers}",
+                               "spring.kafka.producer.bootstrap-servers=${spring.embedded.kafka.brokers}",
                                "consumer.topic=" + TOPIC })
 @EmbeddedKafka(topics = TOPIC, partitions = PARTITIONS)
 @Slf4j
@@ -84,14 +83,13 @@ class ApplicationTests
        /** Tests methods */
 
        @Test
-       @Order(1) // << The poistion pill is not skipped. Hence, this test must run first
        void commitsCurrentOffsetsOnSuccess() throws ExecutionException, InterruptedException
        {
                send100Messages((key, counter) -> serialize(key, counter));
 
                await("100 records received")
                                .atMost(Duration.ofSeconds(30))
-                               .until(() -> receivedRecords.size() >= 100);
+                               .until(() -> receivedRecords.size() == 100);
 
                await("Offsets committed")
                                .atMost(Duration.ofSeconds(10))
@@ -101,35 +99,69 @@ class ApplicationTests
                                        compareToCommitedOffsets(newOffsets);
                                });
 
-               assertThatExceptionOfType(IllegalStateException.class)
-                               .isThrownBy(() -> endlessConsumer.exitStatus())
-                               .describedAs("Consumer should still be running");
+               assertThat(endlessConsumer.isRunning())
+                               .describedAs("Consumer should still be running")
+                               .isTrue();
        }
 
        @Test
-       @Order(2)
-       void commitsOffsetOfErrorForReprocessingOnError()
+       void commitsCurrentOffsetsOnDeserializationError()
        {
                send100Messages((key, counter) ->
                                counter == 77
                                                ? new Bytes(stringSerializer.serialize(TOPIC, "BOOM!"))
                                                : serialize(key, counter));
 
-               await("Consumer failed")
+               await("99 records received")
                                .atMost(Duration.ofSeconds(30))
-                               .untilAsserted(() -> checkSeenOffsetsForProgress());
-
-               compareToCommitedOffsets(newOffsets);
-               assertThat(receivedRecords.size())
-                               .describedAs("Received not all sent events")
-                               .isLessThan(100);
-
-               assertThatNoException()
-                               .describedAs("Consumer should not be running")
-                               .isThrownBy(() -> endlessConsumer.exitStatus());
-               assertThat(endlessConsumer.exitStatus())
-                               .containsInstanceOf(RecordDeserializationException.class)
-                               .describedAs("Consumer should have exited abnormally");
+                               .until(() -> receivedRecords.size() == 99);
+
+               await("Offsets committed")
+                               .atMost(Duration.ofSeconds(10))
+                               .untilAsserted(() ->
+                               {
+                                       // UNSCHÖN:
+                                       // Funktioniert nur, weil nach der Nachrichten, die den
+                                       // Deserialisierungs-Fehler auslöst noch valide Nachrichten
+                                       // gelesen werden.
+                                       // GRUND:
+                                       // Der MessageHandler sieht den Offset der Fehlerhaften
+                                       // Nachricht nicht!
+                                       checkSeenOffsetsForProgress();
+                                       compareToCommitedOffsets(newOffsets);
+                               });
+
+               assertThat(endlessConsumer.isRunning())
+                               .describedAs("Consumer should still be running")
+                               .isTrue();
+       }
+
+       @Test
+       void commitsOffsetOnProgramLogicErrorFoo()
+       {
+               recordHandler.testHandler = (record) ->
+               {
+                       if (Integer.parseInt(record.value().message)%10 ==0)
+                               throw new RuntimeException("BOOM: " + record.value().message + "%10 == 0");
+               };
+
+               send100Messages((key, counter) -> serialize(key, counter));
+
+               await("80 records received")
+                               .atMost(Duration.ofSeconds(30))
+                               .until(() -> receivedRecords.size() == 100);
+
+               await("Offsets committed")
+                               .atMost(Duration.ofSeconds(10))
+                               .untilAsserted(() ->
+                               {
+                                       checkSeenOffsetsForProgress();
+                                       compareToCommitedOffsets(newOffsets);
+                               });
+
+               assertThat(endlessConsumer.isRunning())
+                               .describedAs("Consumer should still be running")
+                               .isTrue();
        }
 
 
@@ -140,7 +172,7 @@ class ApplicationTests
                doForCurrentOffsets((tp, offset) ->
                {
                        Long expected = offsetsToCheck.get(tp) + 1;
-                       log.debug("Checking, if the offset for {} is {}", tp, expected);
+                       log.debug("TEST: Comparing the expected offset of {} for {} to {}", expected, tp, offset);
                        assertThat(offset)
                                        .describedAs("Committed offset corresponds to the offset of the consumer")
                                        .isEqualTo(expected);
@@ -157,10 +189,11 @@ class ApplicationTests
                        Long newOffset = newOffsets.get(tp);
                        if (!oldOffset.equals(newOffset))
                        {
-                               log.debug("Progress for {}: {} -> {}", tp, oldOffset, newOffset);
+                               log.debug("TEST: Progress for {}: {} -> {}", tp, oldOffset, newOffset);
                                withProgress.add(tp);
                        }
                });
+               log.debug("TEST: Offsets with progress: {}", withProgress);
                assertThat(withProgress)
                                .describedAs("Some offsets must have changed, compared to the old offset-positions")
                                .isNotEmpty();
@@ -209,7 +242,7 @@ class ApplicationTests
                                        if (metadata != null)
                                        {
                                                log.debug(
-                                                               "{}|{} - {}={}",
+                                                               "TEST: Sending partition={}, offset={} - {}={}",
                                                                metadata.partition(),
                                                                metadata.offset(),
                                                                record.key(),
@@ -218,7 +251,7 @@ class ApplicationTests
                                        else
                                        {
                                                log.warn(
-                                                               "Exception for {}={}: {}",
+                                                               "TEST: Exception for {}={}: {}",
                                                                record.key(),
                                                                record.value(),
                                                                e.toString());
@@ -256,6 +289,7 @@ class ApplicationTests
                                record ->
                                {
                                        receivedRecords.add(record);
+                                       log.debug("TEST: Processing record #{}: {}", receivedRecords.size(), record.value());
                                        newOffsets.put(
                                                        new TopicPartition(record.topic(), record.partition()),
                                                        record.offset());
@@ -273,7 +307,7 @@ class ApplicationTests
                }
                catch (Exception e)
                {
-                       log.info("Exception while stopping the consumer: {}", e.toString());
+                       log.info("TEST: Exception while stopping the consumer: {}", e.toString());
                }
        }