ROT: Erwartungen an SumBusinessLogic.addToSum(String, Integer)

diff --git a/src/main/java/de/juplo/kafka/AdderBusinessLogic.java b/src/main/java/de/juplo/kafka/AdderBusinessLogic.java
index 1f8ebc2..bd89871 100644 (file)
--- a/src/main/java/de/juplo/kafka/AdderBusinessLogic.java
+++ b/src/main/java/de/juplo/kafka/AdderBusinessLogic.java
@@ -35,6 +35,10 @@ public class AdderBusinessLogic
     return Optional.ofNullable(state.get(user));
   }
 
+  public synchronized void addToSum(String user, Integer value)
+  {
+  }
+
   public synchronized Long endSum(String user)
   {
     if (!state.containsKey(user))

diff --git a/src/test/java/de/juplo/kafka/AdderBusinessLogicTest.java b/src/test/java/de/juplo/kafka/AdderBusinessLogicTest.java
index 8ae1728..6f114d2 100644 (file)
--- a/src/test/java/de/juplo/kafka/AdderBusinessLogicTest.java
+++ b/src/test/java/de/juplo/kafka/AdderBusinessLogicTest.java
@@ -2,6 +2,14 @@ package de.juplo.kafka;
 
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.Arrays;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
 
 import static org.assertj.core.api.Assertions.*;
 
@@ -76,4 +84,59 @@ public class AdderBusinessLogicTest
     AdderBusinessLogic adder = new AdderBusinessLogic();
     assertThatIllegalStateException().isThrownBy(() -> adder.endSum("foo"));
   }
+
+  @Test
+  @DisplayName("Adding to a non-existent sum causes an IllegalStateException")
+  public void testAddToSumCausesExceptionIfNotExists()
+  {
+    AdderBusinessLogic adder = new AdderBusinessLogic();
+    assertThatIllegalStateException().isThrownBy(() -> adder.addToSum("foo", 1));
+  }
+
+  @Test
+  @DisplayName("Adding a null-value to an existing sum causes an IllegalArgumentException")
+  public void testAddNullToExistingSumCausesException()
+  {
+    AdderBusinessLogic adder = new AdderBusinessLogic();
+    adder.startSum("foo");
+    assertThatIllegalArgumentException().isThrownBy(() -> adder.addToSum("foo", null));
+  }
+
+  @ParameterizedTest(name = "{index}: Adding {0}")
+  @DisplayName("Adding a non-positive value to an existing sum causes an IllegalArgumentException")
+  @ValueSource(ints = { 0, -1, -6, -66, Integer.MIN_VALUE })
+  public void testAddingNonPositiveValueToExistingSumCausesException(int value)
+  {
+    AdderBusinessLogic adder = new AdderBusinessLogic();
+    adder.startSum("foo");
+    assertThatIllegalArgumentException().isThrownBy(() -> adder.addToSum("foo", value));
+  }
+
+  @Test
+  @DisplayName("Can add a positive value to an existing sum")
+  public void testCanAddPositiveValueToExistingSum()
+  {
+    AdderBusinessLogic adder = new AdderBusinessLogic();
+    adder.startSum("foo");
+    assertThatIllegalArgumentException().isThrownBy(() -> adder.addToSum("foo", -1));
+  }
+
+  @ParameterizedTest(name = "{index}: Summing up {0}")
+  @DisplayName("Adds up numbers correctly")
+  @MethodSource("numbersProvider")
+  public void testCanAddPositiveValueToExistingSum(int... numbers)
+  {
+    long expectedResult = Arrays.stream(numbers).sum();
+    AdderBusinessLogic adder = new AdderBusinessLogic();
+    adder.startSum("foo");
+    Arrays.stream(numbers).forEach(number -> adder.addToSum("foo", number));
+    assertThat(adder.endSum("foo")).isEqualTo(expectedResult);
+  }
+
+  static Stream<Arguments> numbersProvider() {
+    return Stream.of(
+        Arguments.of((Object) IntStream.rangeClosed(1,9).toArray()),
+        Arguments.of((Object) IntStream.rangeClosed(1,19).toArray()),
+        Arguments.of((Object) IntStream.rangeClosed(1,66).toArray()));
+  }
 }