feat: allow strict mode for Enums in TestCases

If a test-method is annotated with `@TestCase`, any parameter of type
Enum that is annotated with `@Strict` will be checked whether all enum-
values are covered by test-cases. If not, the test will fail at runtime.

Author: Nylle

src/main/java/com/github/nylle/javafixture/annotations/testcases/ReflectedTestCase.java

@@ -31,15 +31,15 @@ public class ReflectedTestCase {
 
     public ReflectedTestCase(TestCase testCase) {
         stream(TestCase.class.getDeclaredMethods())
-                .sorted(Comparator.comparing(Method::getName))
+                .sorted(Comparator.comparing(method -> method.getName()))
                 .forEachOrdered(m -> matrix.compute(m.getReturnType(), (k, v) -> addTo(v, invoke(m, testCase))));
     }
 
     @SuppressWarnings("unchecked")
     public <T> T getTestCaseValueFor(Class<T> type, int i) {
         validate(type, i);
-        if(type.isEnum()) {
-            return (T) Enum.valueOf((Class<Enum>) type, (String)matrix.get(asPrimitive(String.class)).get(i));
+        if (type.isEnum()) {
+            return (T) Enum.valueOf((Class<Enum>) type, (String) matrix.get(asPrimitive(String.class)).get(i));
         }
         return (T) matrix.get(asPrimitive(type)).get(i);
     }
@@ -83,23 +83,22 @@ private static <T> boolean isInvalid(Class<T> type, List<?> nonDefaultValues) {
         if (nonDefaultValues.size() > 1) {
             return true;
         }
-        if(type.isEnum()) {
+        if (type.isEnum()) {
             return false;
         }
         return asPrimitive(type) != asPrimitive(nonDefaultValues.get(0).getClass());
     }
 
     private static Class<?> asPrimitive(Class<?> type) {
-        Map<Class<?>, Class<?>> primitiveWrapperMap = Map.of(
-                Boolean.class, Boolean.TYPE,
-                Character.class, Character.TYPE,
-                Byte.class, Byte.TYPE,
-                Short.class, Short.TYPE,
-                Integer.class, Integer.TYPE,
-                Long.class, Long.TYPE,
-                Float.class, Float.TYPE,
-                Double.class, Double.TYPE
-        );
-        return primitiveWrapperMap.getOrDefault(type, type);
+        return Map.<Class<?>, Class<?>>of(
+                        Boolean.class, Boolean.TYPE,
+                        Character.class, Character.TYPE,
+                        Byte.class, Byte.TYPE,
+                        Short.class, Short.TYPE,
+                        Integer.class, Integer.TYPE,
+                        Long.class, Long.TYPE,
+                        Float.class, Float.TYPE,
+                        Double.class, Double.TYPE)
+                .getOrDefault(type, type);
     }
 }

src/main/java/com/github/nylle/javafixture/annotations/testcases/Strict.java

@@ -0,0 +1,11 @@
+package com.github.nylle.javafixture.annotations.testcases;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Strict {
+}

src/main/java/com/github/nylle/javafixture/annotations/testcases/TestCasesProvider.java

@@ -1,19 +1,22 @@
 package com.github.nylle.javafixture.annotations.testcases;
 
-import com.github.nylle.javafixture.Fixture;
 import com.github.nylle.javafixture.SpecimenType;
 import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.ArgumentsProvider;
 import org.junit.jupiter.params.support.AnnotationConsumer;
 
+import java.lang.annotation.Annotation;
 import java.lang.reflect.Parameter;
 import java.util.List;
+import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
+import static com.github.nylle.javafixture.Fixture.fixture;
 import static java.util.Arrays.stream;
 import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.toMap;
 
 class TestCasesProvider implements ArgumentsProvider, AnnotationConsumer<TestWithCases> {
 
@@ -23,36 +26,96 @@ public void accept(TestWithCases testWithCases) {
 
     @Override
     public Stream<Arguments> provideArguments(ExtensionContext context) {
-        var fixtures = context.getTestMethod().stream()
-                .flatMap(method -> stream(method.getParameters())
-                        .filter(parameter -> hasFixtureAnnotation(parameter))
-                        .map(parameter -> parameter.getParameterizedType())
-                        .map(type -> new Fixture().create(SpecimenType.fromClass(type))))
+        var testMethod = valid(context);
+
+        var fixtures = testMethod.parameters()
+                .filter(parameter -> parameter.getAnnotation(Fixture.class) != null)
+                .map(parameter -> parameter.getParameterizedType())
+                .map(type -> fixture().create(SpecimenType.fromClass(type)))
+                .collect(toList());
+
+        var parameterTypes = testMethod.parameters()
+                .filter(parameter -> parameter.getAnnotation(Fixture.class) == null)
+                .map(parameter -> parameter.getType())
                 .collect(toList());
 
-        return context.getTestMethod().stream()
-                .flatMap(method -> stream(method.getDeclaredAnnotations())
-                        .filter(annotation -> annotation.annotationType().equals(TestCases.class))
-                        .map(cases -> (TestCases) cases)
+        return testMethod.declaredAnnotations(TestCases.class)
                         .flatMap(testCases -> stream(testCases.value()))
-                        .map(testCase -> mapToArguments(testCase, getParameterTypes(context), fixtures)));
+                        .map(testCase -> new ReflectedTestCase(testCase))
+                        .map(testCase -> IntStream.range(0, parameterTypes.size()).boxed().map(i -> testCase.getTestCaseValueFor(parameterTypes.get(i), i)))
+                        .map(caseValues -> Stream.concat(caseValues, fixtures.stream()))
+                        .map(values -> Arguments.of(values.toArray()));
     }
 
-    private static Arguments mapToArguments(TestCase testCase, List<Class<?>> parameters, List<Object> fixtures) {
-        ReflectedTestCase reflectedTestCase = new ReflectedTestCase(testCase);
-        return Arguments.of(Stream.concat(IntStream.range(0, parameters.size()).boxed()
-                .map(i -> reflectedTestCase.getTestCaseValueFor(parameters.get(i), i)), fixtures.stream()).toArray());
-    }
+    private static TestMethod valid(ExtensionContext context) {
+        var testMethod = new TestMethod(context);
+
+        var parameters = testMethod.parameters().collect(toList());
+
+        var strictParamIndices = IntStream.range(0, parameters.size()).boxed().filter(p -> parameters.get(p).getAnnotation(Strict.class) != null).collect(toList());
+        if (strictParamIndices.isEmpty()) {
+            return testMethod;
+        }
+
+        var strictAndFixture = strictParamIndices.stream().filter(p -> parameters.get(p).getAnnotation(Fixture.class) != null).collect(toList());
+        if (!strictAndFixture.isEmpty()) {
+            throw new TestCaseException("Arguments annotated with @Fixture cannot be @Strict: " +
+                                        strictAndFixture.stream()
+                                                .map(i -> parameters.get(i).getName())
+                                                .collect(Collectors.joining(", ")));
+        }
+
+        var strictAndNotEnum = strictParamIndices.stream().filter(p -> !parameters.get(p).getType().isEnum()).collect(toList());
+        if (!strictAndNotEnum.isEmpty()) {
+            throw new TestCaseException("Arguments annotated with @Strict must be of type Enum. The following arguments are not: " +
+                                        strictAndNotEnum.stream()
+                                                .map(i -> parameters.get(i).getName())
+                                                .collect(Collectors.joining(", ")));
+        }
 
-    private static List<Class<?>> getParameterTypes(ExtensionContext context) {
-        return context.getTestMethod().stream()
-                .flatMap(method -> stream(method.getParameters())
-                        .filter(parameter -> !hasFixtureAnnotation(parameter))
-                        .map(parameter -> parameter.getType()))
+        var testCases = testMethod.declaredAnnotations(TestCases.class)
+                .flatMap(cs -> stream(cs.value()))
+                .map(c -> new ReflectedTestCase(c))
                 .collect(toList());
+
+        var parameterTypes = IntStream.range(0, parameters.size()).boxed().collect(toMap(k -> k, v -> parameters.get(v).getType()));
+
+        strictParamIndices.forEach(i -> {
+            var values = testCases.stream().map(x -> x.getTestCaseValueFor(parameterTypes.get(i), i)).collect(toList());
+            var uncovered = stream(((Class<? extends Enum>) parameterTypes.get(i)).getEnumConstants())
+                    .filter(x -> !values.contains(x))
+                    .map(x -> parameterTypes.get(i).getSimpleName() + "." + x)
+                    .collect(Collectors.joining("\n  "));
+            if (!uncovered.isEmpty()) {
+                throw new AssertionError("@Strict requires all Enum values to be covered by test-cases. Missing values for " + parameters.get(i).getName() + ":\n  " + uncovered);
+            }
+        });
+
+        return testMethod;
     }
 
-    private static boolean hasFixtureAnnotation(Parameter parameter) {
-        return parameter.getAnnotation(com.github.nylle.javafixture.annotations.testcases.Fixture.class) != null;
+    private static class TestMethod {
+
+        private final List<Parameter> parameters;
+        private final List<Annotation> declaredAnnotations;
+
+        public TestMethod(ExtensionContext context) {
+            this.parameters = context.getTestMethod().stream()
+                    .flatMap(method -> Stream.ofNullable(method.getParameters()).flatMap(params -> stream(params)))
+                    .collect(toList());
+            this.declaredAnnotations = context.getTestMethod().stream()
+                    .flatMap(method -> Stream.ofNullable(method.getDeclaredAnnotations()).flatMap(annotations -> stream(annotations)))
+                    .collect(toList());
+        }
+
+        public Stream<Parameter> parameters() {
+            return parameters.stream();
+        }
+
+        public <T extends Annotation> Stream<T> declaredAnnotations(Class<T> type) {
+            return declaredAnnotations.stream()
+                    .filter(x -> x.annotationType().equals(type))
+                    .map(x -> (T) x);
+        }
     }
 }

src/test/java/com/github/nylle/javafixture/annotations/testcases/TestCaseExceptionTest.java

@@ -14,6 +14,4 @@ void withMessageAndCause() {
         assertThat(sut.getCause()).isInstanceOf(NullPointerException.class);
         assertThat(sut.getCause().getMessage()).isEqualTo("null");
     }
-
-
 }

src/test/java/com/github/nylle/javafixture/annotations/testcases/TestCaseTest.java

@@ -46,6 +46,14 @@ void canCreateEnumFromString(TestEnum testEnum, String string) {
         assertThat(testEnum).isEqualTo(TestEnum.valueOf(string));
     }
 
+    @TestWithCases
+    @TestCase(str1 = "VALUE1", str2 = "VALUE1")
+    @TestCase(str1 = "VALUE2", str2 = "VALUE2")
+    @TestCase(str1 = "VALUE3", str2 = "VALUE3")
+    void succeedsWhenAllValuesOfStrictEnumAreCoveredByCases(@Strict TestEnum testEnum, String string) {
+        assertThat(testEnum).isEqualTo(TestEnum.valueOf(string));
+    }
+
     @Nested
     @DisplayName("verify that primitive wrapper classes are supported as method arguments")
     class PrimitiveAutoboxing {