[#94] Added possibility to do custom assertions for expected exceptions.

tobiasstamann · tobiasstamann · commit 18c73ce9169a · 2025-05-08T13:51:38.000+02:00
diff --git a/cute/src/main/java/io/toolisticon/cute/AnnotationProcessorWrapper.java b/cute/src/main/java/io/toolisticon/cute/AnnotationProcessorWrapper.java
@@ -12,6 +12,10 @@
 import javax.lang.model.element.PackageElement;
 import javax.lang.model.element.TypeElement;
 import javax.tools.Diagnostic;
+
+import io.toolisticon.cute.CuteApi.ExceptionAssertion;
+import io.toolisticon.cute.CuteApi.ExceptionCheckBB;
+
 import java.util.HashSet;
 import java.util.Set;
 
@@ -21,7 +25,7 @@
 final class AnnotationProcessorWrapper implements Processor {
 
     private final Processor wrappedProcessor;
-    private final Class<? extends Throwable> expectedThrownException;
+    private final ExceptionCheckBB exceptionChecks;
     private Messager messager;
 
     private boolean firstRound = true;
@@ -31,9 +35,9 @@ private AnnotationProcessorWrapper(Processor processor) {
         this(processor, null);
     }
 
-    private AnnotationProcessorWrapper(Processor processor, Class<? extends Throwable> expectedThrownException) {
+    private AnnotationProcessorWrapper(Processor processor, ExceptionCheckBB exceptionChecks) {
         this.wrappedProcessor = processor;
-        this.expectedThrownException = expectedThrownException;
+        this.exceptionChecks = exceptionChecks;
     }
 
 
@@ -83,19 +87,23 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
                 throw (AssertionError) e;
             }
 
-            if (this.expectedThrownException != null) {
+            if (this.exceptionChecks != null && this.exceptionChecks.getExceptionIsThrown() != null) {
 
-                if (!this.expectedThrownException.isAssignableFrom(e.getClass())) {
+                if (!this.exceptionChecks.getExceptionIsThrown().isAssignableFrom(e.getClass())) {
                     throw new FailingAssertionException(
                             Constants.Messages.ASSERTION_GOT_UNEXPECTED_EXCEPTION_INSTEAD_OF_EXPECTED.produceMessage(
-                                    this.expectedThrownException.getCanonicalName(),
+                                    this.exceptionChecks.getExceptionIsThrown().getCanonicalName(),
                                     e.getClass().getCanonicalName(),
                                     e.getMessage() != null ? Constants.Messages.TOKEN__WITH_MESSAGE + e.getMessage() : "")
                             , e);
                 }
 
                 // Exception has been found
                 expectedExceptionWasThrown = true;
+                
+                if (this.exceptionChecks.getExceptionAssertion() != null) {
+                	doExceptionAssertion(this.exceptionChecks.getExceptionAssertion(), (Exception) e);
+                }
 
             } else {
 
@@ -112,15 +120,20 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
         }
 
         // check in last round if expected exception has been thrown - in this case trigger assertion error
-        if (roundEnv.processingOver() && !expectedExceptionWasThrown && this.expectedThrownException != null) {
+        if (roundEnv.processingOver() && !expectedExceptionWasThrown && this.exceptionChecks != null && this.exceptionChecks.getExceptionIsThrown() != null) {
             throw new FailingAssertionException(
-                    Constants.Messages.ASSERTION_EXPECTED_EXCEPTION_NOT_THROWN.produceMessage(this.expectedThrownException.getCanonicalName())
+                    Constants.Messages.ASSERTION_EXPECTED_EXCEPTION_NOT_THROWN.produceMessage(this.exceptionChecks.getExceptionIsThrown().getCanonicalName())
             );
         }
 
 
         return returnValue;
     }
+    
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+	private <EXCEPTION extends Exception> void doExceptionAssertion(ExceptionAssertion exceptionAssertion, Exception e) {
+    	((ExceptionAssertion<EXCEPTION>)exceptionAssertion).doAssertion((EXCEPTION)e);
+    }
 
     @Override
     public Iterable<? extends Completion> getCompletions(Element element, AnnotationMirror annotation, ExecutableElement member, String userText) {
@@ -139,13 +152,13 @@ public static AnnotationProcessorWrapper wrapProcessor(Processor processorToWrap
         return wrapProcessor(processorToWrap, null);
     }
 
-    public static AnnotationProcessorWrapper wrapProcessor(Processor processorToWrap, Class<? extends Throwable> expectedThrownException) {
+    public static AnnotationProcessorWrapper wrapProcessor(Processor processorToWrap, ExceptionCheckBB exceptionChecks) {
 
         if (processorToWrap == null) {
             throw new IllegalArgumentException(Constants.Messages.IAE_PASSED_PARAMETER_MUST_NOT_BE_NULL.produceMessage("processor"));
         }
 
-        return new AnnotationProcessorWrapper(processorToWrap, expectedThrownException);
+        return new AnnotationProcessorWrapper(processorToWrap, exceptionChecks);
     }
 
     public static <T extends Processor> AnnotationProcessorWrapper wrapProcessor(Class<T> processorTypeToWrap) {
@@ -161,18 +174,18 @@ public static <T extends Processor> AnnotationProcessorWrapper wrapProcessor(Cla
 
     }
 
-    public static <T extends Processor> AnnotationProcessorWrapper wrapProcessor(Class<T> processorTypeToWrap, Class<? extends Throwable> expectedThrownException) {
+    public static <T extends Processor> AnnotationProcessorWrapper wrapProcessor(Class<T> processorTypeToWrap, ExceptionCheckBB exceptionChecks) {
 
         if (processorTypeToWrap == null) {
             throw new IllegalArgumentException(Constants.Messages.IAE_PASSED_PARAMETER_MUST_NOT_BE_NULL.produceMessage("type"));
         }
 
-        if (expectedThrownException == null) {
+        if (exceptionChecks == null || exceptionChecks.getExceptionIsThrown() == null) {
             throw new IllegalArgumentException(Constants.Messages.IAE_PASSED_PARAMETER_MUST_NOT_BE_NULL.produceMessage("expected exception"));
         }
 
         try {
-            return new AnnotationProcessorWrapper(processorTypeToWrap.getDeclaredConstructor().newInstance(), expectedThrownException);
+            return new AnnotationProcessorWrapper(processorTypeToWrap.getDeclaredConstructor().newInstance(), exceptionChecks);
         } catch (Exception e) {
             throw new IllegalArgumentException(Constants.Messages.IAE_CANNOT_INSTANTIATE_PROCESSOR.produceMessage(processorTypeToWrap.getCanonicalName()), e);
         }
@@ -258,7 +271,7 @@ static Set<AnnotationProcessorWrapper> getWrappedProcessors(CuteApi.CompilerTest
             }
 
             if (processor != null) {
-                wrappedProcessors.add(AnnotationProcessorWrapper.wrapProcessor(processor, compilerTestBB.getExceptionIsThrown()));
+                wrappedProcessors.add(AnnotationProcessorWrapper.wrapProcessor(processor, compilerTestBB.getExceptionChecks()));
             }
         }
 
@@ -268,7 +281,7 @@ static Set<AnnotationProcessorWrapper> getWrappedProcessors(CuteApi.CompilerTest
             try {
 
                 Processor processor = processorType.getDeclaredConstructor().newInstance();
-                wrappedProcessors.add(AnnotationProcessorWrapper.wrapProcessor(processor, compilerTestBB.getExceptionIsThrown()));
+                wrappedProcessors.add(AnnotationProcessorWrapper.wrapProcessor(processor, compilerTestBB.getExceptionChecks()));
 
             } catch (Exception e) {
                 throw new IllegalArgumentException(Constants.Messages.IAE_CANNOT_INSTANTIATE_PROCESSOR.produceMessage(processorType.getCanonicalName()));
diff --git a/cute/src/main/java/io/toolisticon/cute/CuteApi.java b/cute/src/main/java/io/toolisticon/cute/CuteApi.java
@@ -10,6 +10,7 @@
 import io.toolisticon.fluapigen.api.FluentApiCommand;
 import io.toolisticon.fluapigen.api.FluentApiConverter;
 import io.toolisticon.fluapigen.api.FluentApiImplicitValue;
+import io.toolisticon.fluapigen.api.FluentApiInlineBackingBeanMapping;
 import io.toolisticon.fluapigen.api.FluentApiInterface;
 import io.toolisticon.fluapigen.api.FluentApiParentBackingBeanMapping;
 import io.toolisticon.fluapigen.api.FluentApiRoot;
@@ -68,8 +69,8 @@ public interface CompilerTestBB {
         @FluentApiBackingBeanField("compilationSucceeded")
         Boolean compilationSucceeded();
 
-        @FluentApiBackingBeanField("exceptionIsThrown")
-        Class<? extends Exception> getExceptionIsThrown();
+        @FluentApiBackingBeanField("exceptionChecks")
+        ExceptionCheckBB getExceptionChecks();
 
         UnitTestBase unitTest();
 
@@ -120,6 +121,17 @@ default List<String> getNormalizedCompilerOptions() {
 
 
     }
+    
+    @FluentApiBackingBean
+    public interface ExceptionCheckBB {
+    	
+        @FluentApiBackingBeanField("exceptionIsThrown")
+        Class<? extends Exception> getExceptionIsThrown();
+        
+        @FluentApiBackingBeanField("exceptionAssertion")
+        ExceptionAssertion<? extends Exception> getExceptionAssertion();
+    	
+    }
 
 
     @FluentApiBackingBean
@@ -926,9 +938,34 @@ public interface BlackBoxTestOutcomeInterface {
          * @param exception The exception to check for
          * @return the next fluent interface
          */
-        CompilerTestExpectAndThatInterface exceptionIsThrown(@FluentApiBackingBeanMapping(value = "exceptionIsThrown") Class<? extends Exception> exception);
-
+        @FluentApiInlineBackingBeanMapping(value = "exceptionChecks")
+        CompilerTestExpectAndThatInterface exceptionIsThrown(@FluentApiBackingBeanMapping(value = "exceptionIsThrown", target = TargetBackingBean.INLINE) Class<? extends Exception> exception);
 
+        /**
+         * Expect an Exception to be thrown.
+         * This usually makes sense for unit tests rather than black box tests.
+         * <p>
+         * Please keep in mind that it's discouraged for processors to throw exceptions.
+         * Please catch them in your processor and convert them to compiler messages and maybe trigger a compiler error if needed.
+         *
+         * @param exception The exception to check for
+         * @return the next fluent interface
+         */
+        @FluentApiInlineBackingBeanMapping(value = "exceptionChecks")
+        <T extends Exception> CompilerTestExpectAndThatInterface exceptionIsThrown(
+        		@FluentApiBackingBeanMapping(value = "exceptionIsThrown", target = TargetBackingBean.INLINE) Class<T> exception,
+        		@FluentApiBackingBeanMapping(value = "exceptionAssertion", target = TargetBackingBean.INLINE) ExceptionAssertion<T> exceptionAssertion);
+        
+    }
+    
+    /**
+     * Used to do an assertion on an expected exception.
+     * @param <T> The exceptions type
+     */
+    public interface ExceptionAssertion<T extends Exception> {
+    	
+    	void doAssertion(T exception);
+    	
     }
 
     @FluentApiInterface(CompilerTestBB.class)
diff --git a/cute/src/test/java/io/toolisticon/cute/AnnotationProcessorWrapperTest.java b/cute/src/test/java/io/toolisticon/cute/AnnotationProcessorWrapperTest.java
@@ -1,6 +1,8 @@
 package io.toolisticon.cute;
 
 
+import io.toolisticon.cute.CuteApi.ExceptionAssertion;
+import io.toolisticon.cute.CuteApi.ExceptionCheckBB;
 import io.toolisticon.cute.testcases.TestAnnotationProcessor;
 import io.toolisticon.cute.testcases.TestAnnotationProcessorWithMissingNoArgConstructor;
 import org.hamcrest.MatcherAssert;
@@ -52,23 +54,23 @@ public void createWrapperWithType() {
 
     @Test
     public void createWrapperWithTypeAndException() {
-
-        Processor unit = AnnotationProcessorWrapper.wrapProcessor(TestAnnotationProcessor.class, IllegalStateException.class);
+    	
+        Processor unit = AnnotationProcessorWrapper.wrapProcessor(TestAnnotationProcessor.class, createExceptionCheckBB(IllegalStateException.class));
         MatcherAssert.assertThat("Must return non null valued Processor", unit, Matchers.notNullValue());
 
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void createWrapperWithTypeAndException_nullValuedProcessorClass() {
 
-        AnnotationProcessorWrapper.wrapProcessor((Class) null, IllegalStateException.class);
+        AnnotationProcessorWrapper.wrapProcessor((Class) null, createExceptionCheckBB(IllegalStateException.class));
 
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void createWrapperWithTypeAndException_nullValuedExceptionClass() {
 
-        AnnotationProcessorWrapper.wrapProcessor(TestAnnotationProcessor.class, (Class) null);
+        AnnotationProcessorWrapper.wrapProcessor(TestAnnotationProcessor.class, createExceptionCheckBB((Class) null));
 
     }
 
@@ -87,7 +89,7 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
     @Test(expected = IllegalArgumentException.class)
     public void createWrapperWithTypeAndException_notIntancableProcessorClass() {
 
-        AnnotationProcessorWrapper.wrapProcessor(InvalidProcessor.class, IllegalStateException.class);
+        AnnotationProcessorWrapper.wrapProcessor(InvalidProcessor.class, createExceptionCheckBB(IllegalStateException.class));
 
     }
 
@@ -250,6 +252,39 @@ public void process_testExpectedExceptionIsThrown_assertionShouldSucceed() {
                 .executeTest();
 
 
+    }
+    
+    @Test
+    public void process_testExpectedExceptionIsThrown_assertionShouldSucceed_withAdditionalChecks() {
+
+        Cute.unitTest().when(processingEnvironment -> {
+                    throw new IllegalArgumentException("XXX");
+                })
+                .thenExpectThat().exceptionIsThrown(IllegalArgumentException.class, (e)->{
+                	MatcherAssert.assertThat(e.getMessage(), Matchers.containsString("XXX"));
+                })
+                .executeTest();
+
+       
+    }
+    
+    @Test
+    public void process_testExpectedExceptionIsThrown_assertionShouldFail_becauseOfAdditionalChecks() {
+
+    	try {
+        Cute.unitTest().when(processingEnvironment -> {
+                    throw new IllegalArgumentException("ABC");
+                })
+                .thenExpectThat().exceptionIsThrown(IllegalArgumentException.class, (e)->{
+                	MatcherAssert.assertThat(e.getMessage(), Matchers.containsString("XXX"));
+                })
+               .executeTest();
+    	} catch (AssertionError e) {
+            MatcherAssert.assertThat(e.getMessage(), Matchers.containsString("a string containing \"XXX\""));
+            MatcherAssert.assertThat(e.getMessage(), Matchers.containsString("was \"ABC\""));
+            return;
+        }
+
     }
 
     @Test
@@ -313,4 +348,20 @@ public void getWrappedProcessor_testGet() {
     }
 
 
+    private ExceptionCheckBB createExceptionCheckBB(final Class<? extends Exception> expectedExceptionType) {
+    	return new ExceptionCheckBB() {
+			
+			@Override
+			public Class<? extends Exception> getExceptionIsThrown() {
+				return expectedExceptionType;
+			}
+			
+			@Override
+			public ExceptionAssertion<? extends Exception> getExceptionAssertion() {
+				// TODO Auto-generated method stub
+				return null;
+			}
+		};
+    }
+    
 }
diff --git a/cute/src/test/java/io/toolisticon/cute/CuteApiTest.java b/cute/src/test/java/io/toolisticon/cute/CuteApiTest.java
@@ -171,7 +171,7 @@ public void test_blackbox_exceptionIsThrown() {
                 .andSourceFiles("/compiletests/TestClass.java")
                 .whenCompiled().thenExpectThat().exceptionIsThrown(IllegalStateException.class)
         ).backingBean;
-        MatcherAssert.assertThat(unit.getExceptionIsThrown(), Matchers.is(IllegalStateException.class));
+        MatcherAssert.assertThat(unit.getExceptionChecks().getExceptionIsThrown(), Matchers.is(IllegalStateException.class));
 
     }
 
diff --git a/cute/src/test/java/io/toolisticon/cute/CuteTest.java b/cute/src/test/java/io/toolisticon/cute/CuteTest.java
@@ -1148,6 +1148,37 @@ public void blackBoxTest_checkForExpectedException_happyPath() {
                 .exceptionIsThrown(IllegalStateException.class)
                 .executeTest();
     }
+    
+    @Test
+    public void blackBoxTest_checkForExpectedException_happyPath_withCustomAssertion() {
+        Cute.blackBoxTest().given().processor(ExceptionThrowerProcessor.class)
+                .andSourceFiles("/compiletests/exceptionthrown/ExceptionThrownUsecase.java")
+                .whenCompiled()
+                .thenExpectThat()
+                .exceptionIsThrown(IllegalStateException.class, (e) -> {
+                	MatcherAssert.assertThat(e.getMessage(), Matchers.is("WHOOPS!!!"));
+                })
+                .executeTest();
+    }
+    
+    @Test
+    public void blackBoxTest_checkForExpectedException_failure_becauseOfCustomAssertion() {
+    	try {
+    		Cute.blackBoxTest().given().processor(ExceptionThrowerProcessor.class)
+                .andSourceFiles("/compiletests/exceptionthrown/ExceptionThrownUsecase.java")
+                .whenCompiled()
+                .thenExpectThat()
+                .exceptionIsThrown(IllegalStateException.class, (e) -> {
+                	MatcherAssert.assertThat(e.getMessage(), Matchers.is("NOPE"));
+                })
+                .executeTest();
+    	 } catch (AssertionError e) {
+             MatcherAssert.assertThat(e.getMessage(), Matchers.containsString("NOPE"));
+             return;
+         }
+         throw new AssertionError("Expected an Assertion Error to be thrown");
+    }
+   
 
     @Test
     public void blackBoxTest_checkForExpectedException_failure_otherException() {
diff --git a/legacy/src/main/java/io/toolisticon/cute/CompileTestBuilderApi.java b/legacy/src/main/java/io/toolisticon/cute/CompileTestBuilderApi.java
@@ -42,6 +42,13 @@ public interface CompilerTestBB extends CuteApi.CompilerTestBB {
     }
 
 
+    @FluentApiBackingBean
+    public interface ExceptionCheckBB extends CuteApi.ExceptionCheckBB {
+
+
+    }
+
+    
     @FluentApiBackingBean
     public interface PassInConfigurationBB extends CuteApi.PassInConfigurationBB {
 
@@ -737,7 +744,8 @@ default UnitTestBuilder useSource(String className, String content) {
          * @param expectedException the exceptions expected to be thrown
          * @return the UnitTestBuilder instance
          */
-        UnitTestBuilder expectedThrownException(@FluentApiBackingBeanMapping(value = "exceptionIsThrown") Class<? extends Exception> expectedException);
+        @FluentApiInlineBackingBeanMapping("exceptionChecks")
+        UnitTestBuilder expectedThrownException(@FluentApiBackingBeanMapping(value = "exceptionIsThrown", target = TargetBackingBean.INLINE) Class<? extends Exception> expectedException);
 
 
         /**

Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,7 @@ public void test_blackbox_exceptionIsThrown() {`
`171`	`171`	`.andSourceFiles("/compiletests/TestClass.java")`
`172`	`172`	`.whenCompiled().thenExpectThat().exceptionIsThrown(IllegalStateException.class)`
`173`	`173`	`).backingBean;`
`174`		`- MatcherAssert.assertThat(unit.getExceptionIsThrown(), Matchers.is(IllegalStateException.class));`
	`174`	`+ MatcherAssert.assertThat(unit.getExceptionChecks().getExceptionIsThrown(), Matchers.is(IllegalStateException.class));`
`175`	`175`
`176`	`176`	`}`
`177`	`177`