[FEATURE] Add programmatic assertion API

Author: Lemick

.github/workflows/build.yaml

@@ -0,0 +1,27 @@
+name: Build Project
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Set up JDK
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+          cache: maven
+
+      - name: Build
+        run: mvn clean install

.gitignore

@@ -1,2 +1,33 @@
-# Default ignored files
-/target
+HELP.md
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/

README.md

@@ -1,4 +1,3 @@
-[![Language grade: Java](https://img.shields.io/lgtm/grade/java/g/Lemick/hibernate-spring-sql-query-count.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/Lemick/hibernate-spring-sql-query-count/context:java)
 # Hibernate SQL Query Assertions for Spring
 
 Hibernate is a powerful ORM, but you need to have control over the executed SQL queries to avoid **huge performance problems** (N+1 selects, batch insert not working...) 
@@ -15,7 +14,7 @@ A full-working demo of the examples below [is available here](https://github.com
 
 *Tested versions*: Hibernate 5 & 6 
 
-### Assert SQL statements
+### Assert SQL statements declaratively
 
 You just have to add the `@AssertHibernateSQLCount` annotation to your test and it will verify the SQL statements (SELECT, UPDATE, INSERT, DELETE) count at the end of the test :
 
@@ -37,67 +36,93 @@ void create_two_blog_posts() {
 ```
 If the actual count is different, an exception is thrown with the executed statements:
 ```   
-        com.mickaelb.assertions.HibernateAssertCountException: 
-        Expected 5 INSERT but got 6:
-             => '/* insert com.lemick.demo.entity.BlogPost */ insert into blog_post (id, title) values (default, ?)'
-             => '/* insert com.lemick.demo.entity.PostComment */ insert into post_comment (id, blog_post_id, content) values (default, ?, ?)'
-             => '/* insert com.lemick.demo.entity.PostComment */ insert into post_comment (id, blog_post_id, content) values (default, ?, ?)'
-             => '/* insert com.lemick.demo.entity.BlogPost */ insert into blog_post (id, title) values (default, ?)'
-             => '/* insert com.lemick.demo.entity.PostComment */ insert into post_comment (id, blog_post_id, content) values (default, ?, ?)'
-             => '/* insert com.lemick.demo.entity.PostComment */ insert into post_comment (id, blog_post_id, content) values (default, ?, ?)'
+com.mickaelb.assertions.HibernateAssertCountException: 
+Expected 5 INSERT but got 6:
+     => '/* insert com.lemick.demo.entity.BlogPost */ insert into blog_post (id, title) values (default, ?)'
+     => '/* insert com.lemick.demo.entity.PostComment */ insert into post_comment (id, blog_post_id, content) values (default, ?, ?)'
+     => '/* insert com.lemick.demo.entity.PostComment */ insert into post_comment (id, blog_post_id, content) values (default, ?, ?)'
+     => '/* insert com.lemick.demo.entity.BlogPost */ insert into blog_post (id, title) values (default, ?)'
+     => '/* insert com.lemick.demo.entity.PostComment */ insert into post_comment (id, blog_post_id, content) values (default, ?, ?)'
+     => '/* insert com.lemick.demo.entity.PostComment */ insert into post_comment (id, blog_post_id, content) values (default, ?, ?)'
 ```
-### Assert L2C statistics
+
+### Assert SQL statements programmatically
+
+You can also assert statements from several transactions in your test using the programmatic API:
+```java
+@Test
+void multiple_assertions_using_programmatic_api() {
+    QueryAssertions.assertInsertCount(2, () -> {
+        BlogPost post_1 = new BlogPost("Blog post 1");
+        post_1.addComment(new PostComment("Good article"));
+        blogPostRepository.save(post_1);
+    });
+
+    QueryAssertions.assertSelectCount(1, () -> blogPostRepository.findById(1L));
+
+    // Or even multiple asserts at once
+    QueryAssertions.assertStatementCount(Map.of(INSERT, 2, SELECT, 1), () -> {
+        BlogPost post_1 = new BlogPost("Blog post 1");
+        post_1.addComment(new PostComment("Good article"));
+        blogPostRepository.save(post_1);
+
+        blogPostRepository.findById(1L);
+    });
+}
+```
+
+### Assert L2C statistics declaratively
 
 It supports assertions on Hibernate level two cache statistics, useful for checking that your entities are cached correctly and that they will stay forever:
 ```java
-    @Test
-    @AssertHibernateL2CCount(misses = 1, puts = 1, hits = 1)
-    void create_one_post_and_read_it() {
-        doInTransaction(() -> {
-            BlogPost post_1 = new BlogPost("Blog post 1");
-            blogPostRepository.save(post_1);
-        });
-
-        doInTransaction(() -> {
-            blogPostRepository.findById(1L); // 1 MISS + 1 PUT
-        });
-
-        doInTransaction(() -> {
-            blogPostRepository.findById(1L); // 1 HIT
-        });
-    }
+@Test
+@AssertHibernateL2CCount(misses = 1, puts = 1, hits = 1)
+void create_one_post_and_read_it() {
+    doInTransaction(() -> {
+        BlogPost post_1 = new BlogPost("Blog post 1");
+        blogPostRepository.save(post_1);
+    });
+
+    doInTransaction(() -> {
+        blogPostRepository.findById(1L); // 1 MISS + 1 PUT
+    });
+
+    doInTransaction(() -> {
+        blogPostRepository.findById(1L); // 1 HIT
+    });
+}
 ```
 ## How to integrate
 1. Import the dependency
-	```xml
-	<dependency>
-		<groupId>com.mickaelb</groupId>
-		<artifactId>hibernate-query-asserts</artifactId>
-		<version>2.0.0</version>
-	</dependency>
-	```
+    ```xml
+    <dependency>
+        <groupId>com.mickaelb</groupId>
+        <artifactId>hibernate-query-asserts</artifactId>
+        <version>2.0.0</version>
+    </dependency>
+    ```
 2. Register the integration with Hibernate, you just need to add this key in your configuration (here for yml):
 
         spring:
-            jpa:
-                properties:
-                    hibernate.session_factory.statement_inspector: com.mickaelb.integration.hibernate.HibernateStatementInspector
+          jpa:
+            properties:
+              hibernate.session_factory.statement_inspector: com.mickaelb.integration.hibernate.HibernateStatementInspector
 
 3. Register the Spring TestListener that will launch the SQL inspection if the annotation is present:
 
     * By adding the listener on each of your integration test: 
 	```java
-    @SpringBootTest
-    @TestExecutionListeners(
-		listeners = HibernateAssertTestListener.class, 
-		mergeMode = TestExecutionListeners.MergeMode.MERGE_WITH_DEFAULTS
-    )
-    class MySpringIntegrationTest {
-       ...
-    }
+   @SpringBootTest
+   @TestExecutionListeners(
+       listeners = HibernateAssertTestListener.class, 
+       mergeMode = TestExecutionListeners.MergeMode.MERGE_WITH_DEFAULTS
+   )
+   class MySpringIntegrationTest {
+      ...
+   }
 	```
 
     * **OR** by adding a **META-INF/spring.factories** file that contains the definition, that will register the listener for all your tests:
 	```
-	 org.springframework.test.context.TestExecutionListener=com.mickaelb.integration.spring.HibernateAssertTestListener
+	org.springframework.test.context.TestExecutionListener=com.mickaelb.integration.spring.HibernateAssertTestListener
 	```

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.mickaelb</groupId>
     <artifactId>hibernate-query-asserts</artifactId>
-    <version>2.0.0-SNAPSHOT</version>
+    <version>2.1.0-SNAPSHOT</version>
 
     <name>${project.groupId}:${project.artifactId}</name>
     <description>A library that can assert statement generated by Hibernate in Spring tests</description>

src/main/java/com/mickaelb/api/QueryAssertions.java

@@ -0,0 +1,76 @@
+package com.mickaelb.api;
+
+import com.mickaelb.integration.spring.assertions.sql.HibernateStatementAssertionResult;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+import static com.mickaelb.api.StatementType.*;
+import static com.mickaelb.integration.hibernate.HibernateStatementInspector.getStatistics;
+
+public class QueryAssertions {
+
+    private static final Map<StatementType, Supplier<List<String>>> STATEMENT_SUPPLIERS = Map.of(
+            INSERT, () -> getStatistics().getInsertStatements(),
+            UPDATE, () -> getStatistics().getUpdateStatements(),
+            SELECT, () -> getStatistics().getSelectStatements(),
+            DELETE, () -> getStatistics().getDeleteStatements()
+    );
+
+    private QueryAssertions() {
+    }
+
+    public static void assertInsertCount(int expectedInsertCount, Runnable runnable) {
+        doAssertStatementCount(runnable, INSERT, expectedInsertCount);
+    }
+
+    public static void assertUpdateCount(int expectedUpdateCount, Runnable runnable) {
+        doAssertStatementCount(runnable, UPDATE, expectedUpdateCount);
+    }
+
+    public static void assertSelectCount(int expectedSelectCount, Runnable runnable) {
+        doAssertStatementCount(runnable, SELECT, expectedSelectCount);
+    }
+
+    public static void assertDeleteCount(int expectedDeleteCount, Runnable runnable) {
+        doAssertStatementCount(runnable, DELETE, expectedDeleteCount);
+    }
+
+    public static void assertStatementCount(Map<StatementType, Integer> expectedCounts, Runnable runnable) {
+        Map<StatementType, Integer> sizesBeforeExecution = expectedCounts.keySet().stream()
+                .collect(Collectors.toMap(
+                        statementType -> statementType,
+                        statementType -> STATEMENT_SUPPLIERS.get(statementType).get().size()
+                ));
+
+        runnable.run();
+
+        for (Map.Entry<StatementType, Integer> entry : expectedCounts.entrySet()) {
+            StatementType statementType = entry.getKey();
+            int expectedCount = entry.getValue();
+
+            Supplier<List<String>> statementSupplier = STATEMENT_SUPPLIERS.get(statementType);
+            List<String> fullStatements = statementSupplier.get();
+
+            int sizeBeforeExecution = sizesBeforeExecution.get(statementType);
+            List<String> executionScopedStatements = fullStatements.subList(sizeBeforeExecution, fullStatements.size());
+
+            HibernateStatementAssertionResult assertionResult = new HibernateStatementAssertionResult(statementType, executionScopedStatements, expectedCount);
+            assertionResult.validate();
+        }
+    }
+
+    private static void doAssertStatementCount(Runnable runnable, StatementType statementType, int expectedCount) {
+        Supplier<List<String>> statementSupplier = STATEMENT_SUPPLIERS.get(statementType);
+        int sizeBeforeExecution = statementSupplier.get().size();
+        runnable.run();
+
+        List<String> fullStatements = statementSupplier.get();
+        List<String> executionScopedStatements = fullStatements.subList(sizeBeforeExecution, fullStatements.size());
+
+        HibernateStatementAssertionResult assertionResult = new HibernateStatementAssertionResult(statementType, executionScopedStatements, expectedCount);
+        assertionResult.validate();
+    }
+}

src/main/java/com/mickaelb/api/StatementType.java

@@ -0,0 +1,5 @@
+package com.mickaelb.api;
+
+public enum StatementType {
+    SELECT, INSERT, UPDATE, DELETE
+}

src/main/java/com/mickaelb/integration/hibernate/HibernateStatementStatistics.java

@@ -15,7 +15,6 @@ public void resetStatistics() {
         updateStatements.clear();
         insertStatements.clear();
         deleteStatements.clear();
-
     }
 
     @Override
@@ -39,18 +38,18 @@ public void notifyDeleteStatement(String sql) {
     }
 
     public List<String> getSelectStatements() {
-        return selectStatements;
+        return new ArrayList<>(selectStatements);
     }
 
     public List<String> getUpdateStatements() {
-        return updateStatements;
+        return new ArrayList<>(updateStatements);
     }
 
     public List<String> getInsertStatements() {
-        return insertStatements;
+        return new ArrayList<>(insertStatements);
     }
 
     public List<String> getDeleteStatements() {
-        return deleteStatements;
+        return new ArrayList<>(deleteStatements) ;
     }
 }

src/main/java/com/mickaelb/integration/spring/HibernateL2CCountTestListener.java

@@ -27,10 +27,7 @@ public void beforeTestClass(TestContext testContext) {
 
     @Override
     public void beforeTestMethod(TestContext testContext) {
-        AssertHibernateL2CCount l2cCountAnnotation = testContext.getTestMethod().getAnnotation(AssertHibernateL2CCount.class);
-        if (l2cCountAnnotation != null) {
-            sessionFactoryStatistics.clear();
-        }
+        sessionFactoryStatistics.clear();
     }
 
     @Override

src/main/java/com/mickaelb/integration/spring/HibernateSQLCountTestListener.java

@@ -12,26 +12,20 @@
 import java.util.List;
 import java.util.function.Supplier;
 
-import static com.mickaelb.integration.spring.assertions.sql.HibernateStatementAssertionResult.StatementType.*;
-import static com.mickaelb.integration.spring.assertions.sql.HibernateStatementAssertionResult.StatementType.DELETE;
+import static com.mickaelb.api.StatementType.*;
 
 public class HibernateSQLCountTestListener implements AssertTestListener{
 
     private Supplier<HibernateStatementStatistics> statisticsSupplier = HibernateStatementInspector::getStatistics;
     private Supplier<Boolean> transactionAvailabilitySupplier = TestTransaction::isActive;
 
-
     @Override
     public void beforeTestClass(TestContext testContext) {
-
     }
 
     @Override
     public void beforeTestMethod(TestContext testContext) {
-        AssertHibernateSQLCount sqlCountAnnotation = testContext.getTestMethod().getAnnotation(AssertHibernateSQLCount.class);
-        if (sqlCountAnnotation != null) {
-            statisticsSupplier.get().resetStatistics();
-        }
+        statisticsSupplier.get().resetStatistics();
     }
 
     @Override
@@ -41,7 +35,6 @@ public void afterTestMethod(TestContext testContext) {
             flushExistingPersistenceContext(testContext, transactionAvailabilitySupplier);
             evaluateSQLStatementCount(sqlCountAnnotation);
         }
-
     }
 
     private void flushExistingPersistenceContext(TestContext testContext, Supplier<Boolean> transactionAvailabilitySupplier) {