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.*;
public class AdderBusinessLogicTest
{
@Test
- @DisplayName("A new sum can be started, if it does not exist")
- public void testCanStartSumIfNotExists()
+ @DisplayName("An empty Optional should be returned, for a non-existing sum")
+ public void testGetSumReturnsEmptyOptionalForNonExistingSum()
{
AdderBusinessLogic adder = new AdderBusinessLogic();
- assertThatNoException().isThrownBy(() -> adder.startSum("foo"));
+ assertThat(adder.getSum("foo")).isEmpty();
}
@Test
- @DisplayName("Starting an already existing sum again, causes an IllegalStateException")
- public void testStartSumCausesExceptionIfExists()
+ @DisplayName("A non-empty Optional should be returned, for an existing sum")
+ public void testGetSumReturnsNonEmptyOptionalForExistingSum()
{
AdderBusinessLogic adder = new AdderBusinessLogic();
- adder.startSum("foo");
- assertThatIllegalStateException().isThrownBy(() -> adder.startSum("foo"));
+ adder.addToSum("foo", 6);
+ assertThat(adder.getSum("foo")).isNotEmpty();
}
@Test
- @DisplayName("An empty Optional should be returned, for a non-existing sum")
- public void testEmptyOptionalForNonExistingSum()
+ @DisplayName("A sum can be calculated, if it does exist")
+ public void testCalculatePossibleIfSumExists()
{
AdderBusinessLogic adder = new AdderBusinessLogic();
- assertThat(adder.getSum("foo")).isEmpty();
+ adder.addToSum("foo", 6);
+ assertThatNoException().isThrownBy(() -> adder.calculate("foo"));
}
@Test
- @DisplayName("A non-empty Optional should be returned, for an existing sum")
- public void testNonEmptyOptionalForExistingSum()
+ @DisplayName("An existing sum is removed, if ended")
+ public void testCalculateRemovesSumIfSumExists()
{
AdderBusinessLogic adder = new AdderBusinessLogic();
- adder.startSum("foo");
- assertThat(adder.getSum("foo")).isNotEmpty();
+ adder.addToSum("foo", 6);
+ adder.calculate("foo");
+ assertThat(adder.getSum("foo")).isEmpty();
}
@Test
- @DisplayName("A sum can be ended, if it does exist")
- public void testCanEndIfSumExists()
+ @DisplayName("An existing sum returns a non-null value, if calculated")
+ public void testCalculateReturnsNonNullValueIfSumExists()
{
AdderBusinessLogic adder = new AdderBusinessLogic();
- adder.startSum("foo");
- assertThatNoException().isThrownBy(() -> adder.endSum("foo"));
+ adder.addToSum("foo", 6);
+ assertThat(adder.calculate("foo")).isNotNull();
}
@Test
- @DisplayName("An existing Sum returns a non-null value, if ended")
- public void testEndSumReturnsNonNullValueIfSumExists()
+ @DisplayName("Ending a non-existing sum, causes an IllegalStateException")
+ public void testCalculateCausesExceptionIfNotExists()
{
AdderBusinessLogic adder = new AdderBusinessLogic();
- adder.startSum("foo");
- assertThat(adder.endSum("foo")).isNotNull();
+ assertThatIllegalStateException().isThrownBy(() -> adder.calculate("foo"));
}
@Test
- @DisplayName("An existing Sum returns a non-negative value, if ended")
- public void testEndSumReturnsNonNegativeValueIfSumExists()
+ @DisplayName("Adding a null-value to a sum causes an IllegalArgumentException")
+ public void testAddToSumWithNullValueCausesException()
{
AdderBusinessLogic adder = new AdderBusinessLogic();
- adder.startSum("foo");
- assertThat(adder.endSum("foo")).isNotNegative();
+ assertThatIllegalArgumentException().isThrownBy(() -> adder.addToSum("foo", null));
}
- @Test
- @DisplayName("Ending a non-existing sum, causes an IllegalStateException")
- public void testEndSumCausesExceptionIfNotExists()
+ @ParameterizedTest(name = "{index}: Adding {0}")
+ @DisplayName("Adding a non-positive value to a sum causes an IllegalArgumentException")
+ @ValueSource(ints = { 0, -1, -6, -66, Integer.MIN_VALUE })
+ public void testAddToSumWithNonPositiveValueCausesException(int value)
+ {
+ AdderBusinessLogic adder = new AdderBusinessLogic();
+ assertThatIllegalArgumentException().isThrownBy(() -> adder.addToSum("foo", value));
+ }
+
+ @ParameterizedTest(name = "{index}: Adding {0}")
+ @DisplayName("Can add a positive value to a sum")
+ @ValueSource(ints = { 1, 3, 6, 66, 7, 9 })
+ public void testAddToSumWithPositiveValuePossible(int value)
{
AdderBusinessLogic adder = new AdderBusinessLogic();
- assertThatIllegalStateException().isThrownBy(() -> adder.endSum("foo"));
+ assertThatNoException().isThrownBy(() -> adder.addToSum("foo", value));
+ }
+
+ @ParameterizedTest(name = "{index}: Summing up {0}")
+ @DisplayName("Adds up numbers correctly")
+ @MethodSource("numbersProvider")
+ public void testAddToSumAddsUpNumbersCorrectlyIfSumExists(int... numbers)
+ {
+ long expectedResult = Arrays.stream(numbers).sum();
+ AdderBusinessLogic adder = new AdderBusinessLogic();
+ Arrays.stream(numbers).forEach(number -> adder.addToSum("foo", number));
+ AdderResult result = adder.calculate("foo");
+ assertThat(result.number).isEqualTo(numbers[numbers.length-1]);
+ assertThat(result.sum).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()));
}
}