assertions can be done without annotation | Listener clean statistics even without annotation

Author: Lemick

pom.xml

@@ -49,4 +49,14 @@
             <scope>test</scope>
         </dependency>
     </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>3.0.0-M6</version>
+            </plugin>
+        </plugins>
+    </build>
 </project>

src/main/java/com/lemick/api/AssertSQLStatementCount.java renamed to src/main/java/com/lemick/api/AssertHibernateSQLStatementCount.java

@@ -7,7 +7,7 @@
 
 @Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
-public @interface AssertSQLStatementCount {
+public @interface AssertHibernateSQLStatementCount {
 
     int selects() default 0;
 

src/main/java/com/lemick/assertions/HibernateStatementAssertUtils.java

@@ -1,6 +1,6 @@
 package com.lemick.assertions;
 
-public class HibernateStatementAssertionResult {
+public class HibernateStatementAssertionResult implements HibernateStatementAssertionValidator {
 
     public enum StatementType {SELECT, INSERT, UPDATE, DELETE}
 
@@ -21,4 +21,11 @@ public boolean isInError() {
     public String getErrorMessage() {
         return "Expected " + expected + " " + type.name() + " but was " + actual;
     }
+
+    @Override
+    public void validate() {
+        if (this.isInError()) {
+            throw new HibernateStatementCountException(this.getErrorMessage());
+        }
+    }
 }

src/main/java/com/lemick/assertions/HibernateStatementAssertionResult.java

@@ -3,14 +3,15 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class HibernateStatementAssertionResults {
+public class HibernateStatementAssertionResults implements HibernateStatementAssertionValidator {
 
-    private List<HibernateStatementAssertionResult> assertionResults;
+    private final List<HibernateStatementAssertionResult> assertionResults;
 
     public HibernateStatementAssertionResults(List<HibernateStatementAssertionResult> statementAssertionResults) {
         this.assertionResults = statementAssertionResults;
     }
 
+    @Override
     public void validate() {
         List<HibernateStatementAssertionResult> assertionsInError = assertionResults.stream()
                 .filter(HibernateStatementAssertionResult::isInError)

src/main/java/com/lemick/assertions/HibernateStatementAssertionResults.java

@@ -0,0 +1,5 @@
+package com.lemick.assertions;
+
+public interface HibernateStatementAssertionValidator {
+    void validate();
+}

src/main/java/com/lemick/assertions/HibernateStatementAssertionValidator.java

@@ -0,0 +1,32 @@
+package com.lemick.assertions;
+
+
+import com.lemick.integration.hibernate.HibernateStatementCountInspector;
+import com.lemick.integration.hibernate.HibernateStatistics;
+
+import java.util.function.Supplier;
+
+import static com.lemick.assertions.HibernateStatementAssertionResult.StatementType.*;
+
+public class HibernateStatementAssertionsProvider {
+
+    public HibernateStatementAssertionResult generateInsertStatementAssertion(int expectedInsertStatementCount, Supplier<HibernateStatistics> statisticsSupplier) {
+        return new HibernateStatementAssertionResult(INSERT, statisticsSupplier.get().getInsertStatementCount(), expectedInsertStatementCount);
+    }
+
+    public HibernateStatementAssertionResult generateUpdateStatementAssertion(int expectedUpdateStatementCount, Supplier<HibernateStatistics> statisticsSupplier) {
+        return new HibernateStatementAssertionResult(UPDATE, statisticsSupplier.get().getUpdateStatementCount(), expectedUpdateStatementCount);
+    }
+
+    public HibernateStatementAssertionResult generateSelectStatementAssertion(int expectedSelectStatementCount, Supplier<HibernateStatistics> statisticsSupplier) {
+        return new HibernateStatementAssertionResult(SELECT, statisticsSupplier.get().getSelectStatementCount(), expectedSelectStatementCount);
+    }
+
+    public HibernateStatementAssertionResult generateDeleteStatementAssertion(int expectedDeleteStatementCount, Supplier<HibernateStatistics> statisticsSupplier) {
+        return new HibernateStatementAssertionResult(DELETE, statisticsSupplier.get().getDeleteStatementCount(), expectedDeleteStatementCount);
+    }
+
+    public void resetStatistics() {
+        HibernateStatementCountInspector.resetStatistics();
+    }
+}

src/main/java/com/lemick/assertions/HibernateStatementAssertionsProvider.java

@@ -0,0 +1,32 @@
+package com.lemick.assertions;
+
+
+import com.lemick.integration.hibernate.HibernateStatementCountInspector;
+import com.lemick.integration.hibernate.HibernateStatistics;
+
+import java.util.function.Supplier;
+
+/**
+ * Static assertion class usable in tests
+ */
+public class HibernateStatementAssertionsUtils {
+
+    private static final HibernateStatementAssertionsProvider hibernateStatementAssertionsProvider = new HibernateStatementAssertionsProvider();
+    private static final Supplier<HibernateStatistics> statisticsSupplier = HibernateStatementCountInspector::getStatistics;
+
+    public static void assertInsertStatementCount(int expectedInsertStatementCount) {
+        hibernateStatementAssertionsProvider.generateInsertStatementAssertion(expectedInsertStatementCount, statisticsSupplier).validate();
+    }
+
+    public static void assertUpdateStatementCount(int expectedUpdateStatementCount) {
+        hibernateStatementAssertionsProvider.generateUpdateStatementAssertion(expectedUpdateStatementCount, statisticsSupplier).validate();
+    }
+
+    public static void assertSelectStatementCount(int expectedSelectStatementCount) {
+        hibernateStatementAssertionsProvider.generateSelectStatementAssertion(expectedSelectStatementCount, statisticsSupplier).validate();
+    }
+
+    public static void assertDeleteStatementCount(int expectedDeleteStatementCount) {
+        hibernateStatementAssertionsProvider.generateDeleteStatementAssertion(expectedDeleteStatementCount, statisticsSupplier).validate();
+    }
+}

src/main/java/com/lemick/assertions/HibernateStatementAssertionsUtils.java

@@ -1,42 +1,37 @@
 package com.lemick.integration.spring;
 
 
-import com.lemick.api.AssertSQLStatementCount;
-import com.lemick.assertions.HibernateStatementAssertUtils;
+import com.lemick.api.AssertHibernateSQLStatementCount;
 import com.lemick.assertions.HibernateStatementAssertionResults;
+import com.lemick.assertions.HibernateStatementAssertionsProvider;
+import com.lemick.integration.hibernate.HibernateStatementCountInspector;
+import com.lemick.integration.hibernate.HibernateStatistics;
 import org.springframework.core.Ordered;
 import org.springframework.test.context.TestContext;
 import org.springframework.test.context.TestExecutionListener;
 
 import java.util.List;
+import java.util.function.Supplier;
 
-/**
- * TODO
- * Permettre les asserts dans le test
- * Augmenter les type d'assert (mise en cache, etc...)
- * Classe Thread-safe
- */
 public class HibernateStatementCountTestListener implements TestExecutionListener, Ordered {
 
-    private HibernateStatementAssertUtils hibernateStatementAssertUtils = new HibernateStatementAssertUtils();
+    private HibernateStatementAssertionsProvider hibernateStatementAssertionsProvider = new HibernateStatementAssertionsProvider();
+    private Supplier<HibernateStatistics> statisticsSupplier = HibernateStatementCountInspector::getStatistics;
 
     @Override
     public void beforeTestMethod(TestContext testContext) {
-        AssertSQLStatementCount annotation = testContext.getTestMethod().getAnnotation(AssertSQLStatementCount.class);
-        if (annotation != null) {
-            hibernateStatementAssertUtils.resetCounts();
-        }
+        hibernateStatementAssertionsProvider.resetStatistics();
     }
 
     @Override
     public void afterTestMethod(TestContext testContext) {
-        AssertSQLStatementCount annotation = testContext.getTestMethod().getAnnotation(AssertSQLStatementCount.class);
+        AssertHibernateSQLStatementCount annotation = testContext.getTestMethod().getAnnotation(AssertHibernateSQLStatementCount.class);
         if (annotation != null) {
             HibernateStatementAssertionResults assertionResults = new HibernateStatementAssertionResults(List.of(
-                    hibernateStatementAssertUtils.assertSelectStatementCount(annotation.selects()),
-                    hibernateStatementAssertUtils.assertUpdateStatementCount(annotation.updates()),
-                    hibernateStatementAssertUtils.assertInsertStatementCount(annotation.inserts()),
-                    hibernateStatementAssertUtils.assertDeleteStatementCount(annotation.deletes())
+                    hibernateStatementAssertionsProvider.generateSelectStatementAssertion(annotation.selects(), statisticsSupplier),
+                    hibernateStatementAssertionsProvider.generateUpdateStatementAssertion(annotation.updates(), statisticsSupplier),
+                    hibernateStatementAssertionsProvider.generateInsertStatementAssertion(annotation.inserts(), statisticsSupplier),
+                    hibernateStatementAssertionsProvider.generateDeleteStatementAssertion(annotation.deletes(), statisticsSupplier)
             ));
             assertionResults.validate();
         }

src/main/java/com/lemick/integration/spring/HibernateStatementCountTestListener.java

@@ -8,17 +8,31 @@
 class HibernateStatementAssertionResultTest {
 
     @Test
-    public void _result_in_error() {
+    public void _isInError_true() {
         HibernateStatementAssertionResult model = new HibernateStatementAssertionResult(SELECT, 0, 1);
 
         assertTrue(model.isInError(), "the result is in error");
         assertEquals("Expected 1 SELECT but was 0", model.getErrorMessage(), "the error message is correct");
     }
 
     @Test
-    public void _result_not_in_error() {
+    public void _isInError_false() {
         HibernateStatementAssertionResult model = new HibernateStatementAssertionResult(SELECT, 1, 1);
 
         assertFalse(model.isInError(), "the result is not in error");
     }
+
+    @Test
+    public void _validate_does_not_throw() {
+        HibernateStatementAssertionResult model = new HibernateStatementAssertionResult(SELECT, 1, 1);
+
+        assertDoesNotThrow(model::validate);
+    }
+
+    @Test
+    public void _validate_throws() {
+        HibernateStatementAssertionResult model = new HibernateStatementAssertionResult(SELECT, 2, 1);
+
+        assertThrows(HibernateStatementCountException.class, model::validate);
+    }
 }