moved test helper to own jar

Author: sterlp

CHANGELOG.md

@@ -9,6 +9,7 @@
 -   Added Re-Queue / Re-Run trigger to history page
 -   Correlation Id is shown in the UI
 -   ID search includes also Correlation Id
+-   Moved helper classes to own test jar
 
 ## v1.5.6 - (2025-03-06)
 

core/pom.xml

@@ -51,6 +51,12 @@
             <version>${project.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>spring-persistent-tasks-test</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
 
         <dependency>
             <groupId>org.liquibase</groupId>
@@ -83,6 +89,12 @@
             <artifactId>mssql-jdbc</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.sterl.test</groupId>
+            <artifactId>hibernate-asserts</artifactId>
+            <version>1.0.0</version>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.postgresql</groupId>
             <artifactId>postgresql</artifactId>

core/src/test/java/org/sterl/spring/persistent_tasks/AbstractSpringTest.java

@@ -32,7 +32,7 @@
 import org.sterl.spring.persistent_tasks.trigger.model.TriggerEntity;
 import org.sterl.spring.sample_app.SampleApp;
 import org.sterl.test.AsyncAsserts;
-import org.sterl.test.HibernateAsserts;
+import org.sterl.test.hibernate_asserts.HibernateAsserts;
 
 import jakarta.persistence.EntityManager;
 import lombok.RequiredArgsConstructor;

core/src/test/java/org/sterl/test/HibernateAsserts.java

@@ -64,6 +64,7 @@
         <module>db</module>
         <module>ui</module>
         <module>core</module>
+        <module>test</module>
     </modules>
 
     <dependencyManagement>

pom.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.sterl.spring</groupId>
+        <artifactId>spring-persistent-tasks-root</artifactId>
+        <version>1.6.0-SNAPSHOT</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+
+    <artifactId>spring-persistent-tasks-test</artifactId>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+        </dependency>
+    </dependencies>
+</project>

test/pom.xml

@@ -1,7 +1,7 @@
 package org.sterl.test;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.fail;
+import static org.assertj.core.api.Assertions.fail;
 
 import java.time.Duration;
 import java.time.Instant;
@@ -13,30 +13,33 @@
 
 import org.assertj.core.api.ListAssert;
 
+import lombok.Getter;
 import lombok.Setter;
 
 public class AsyncAsserts {
 
     private final List<String> values = Collections.synchronizedList(new ArrayList<String>());
     private final Map<String, Integer> counts = new ConcurrentHashMap<>();
-    @Setter
-    private Duration defaultTimeout = Duration.ofSeconds(3);
 
+    @Getter @Setter
+    private int maxStepCount = 100;
+    
+    @Getter @Setter
+    private Duration defaultTimeout = Duration.ofSeconds(3);
+    
     public synchronized void clear() {
         values.clear();
         counts.clear();
     }
-
-    public int add(String value) {
+    public synchronized int add(String value) {
         values.add(value);
         final int count = getCount(value) + 1;
         counts.put(value, count);
-        if (values.size() > 100) {
-            throw new IllegalStateException("Workflow has already more than 100 steps, assuming error!");
+        if (values.size() > maxStepCount) {
+            throw new IllegalStateException("Flow has already more than " + maxStepCount + " steps, assuming error!");
         }
         return count;
     }
-
     /**
      * @return how often this value has been already added ...
      */
@@ -53,53 +56,55 @@ public int info(String value) {
         System.err.println(size + ". " + value);
         return count;
     }
-
-    public int getCount(String value) {
-        return counts.getOrDefault(value, 0);
-    }
     public int getCount() {
         return counts.size();
     }
-
+    
+    public int getCount(String value) {
+        return counts.getOrDefault(value, 0);
+    }
     public void awaitValue(String value) {
-        final var start = Instant.now();
+        awaitValue(null, value);
+    }
+    /**
+     * Wait for the given value, if not found call the given method
+     * @param fn the optional function to call after each wait
+     * @param value the value to wait for
+     */
+    public void awaitValue(Runnable fn, String value) {
+        final var start = System.currentTimeMillis();
         while (!values.contains(value)
-                && (System.currentTimeMillis() - start.toEpochMilli() <= defaultTimeout.toMillis())) {
+                && (System.currentTimeMillis() - start <= defaultTimeout.toMillis())) {
             try {
-                Thread.sleep(100);
+                Thread.sleep(50);
+                if (fn != null) fn.run();
             } catch (InterruptedException e) {
-                if (Thread.interrupted()) {
-                    break;
-                }
+                if (Thread.interrupted()) break;
             }
         }
         assertValue(value);
     }
-
-    public ListAssert<String> assertValue(String value) {
-        return assertThat(new ArrayList<>(values)).contains(value);
-    }
-
-    public void awaitValue(String value, String... values) {
-        awaitValue(value);
+    /**
+     * Wait for the given value, if not found call the given method
+     * @param fn the optional function to call after each wait
+     * @param value the value to wait for
+     */
+    public void awaitValue(Runnable fn, String value, String... values) {
+        awaitValue(fn, value);
         if (values != null && values.length > 0) {
             for (String v : values) {
-                awaitValue(v);
+                awaitValue(fn, v);
             }
         }
     }
-
-    public void awaitValueOnce(String value) {
-        awaitValue(value);
-        assertThat(values).contains(value);
-        var occurrences = values.stream().filter(e -> value.equals(e)).count();
-        if (occurrences > 1) {
-            fail("Expected " + value + " to be present once but was present " + occurrences + " times.");
-        }
+    public void awaitValue(String value, String... values) {
+        awaitValue(null, value, values);
     }
-
     public void awaitOrdered(String value, String... values) {
-        awaitValue(value, values);
+        awaitOrdered(null, value, values);
+    }
+    public void awaitOrdered(Runnable fn, String value, String... values) {
+        awaitValue(fn, value, values);
 
         assertThat(this.values.indexOf(value)).isEqualTo(0);
         if (values != null && values.length > 0) {
@@ -108,7 +113,11 @@ public void awaitOrdered(String value, String... values) {
             }
         }
     }
-
+    
+    public ListAssert<String> assertValue(String value) {
+        return assertThat(new ArrayList<>(values)).contains(value);
+    }
+    
     public void assertMissing(String value) {
         assertThat(values).doesNotContain(value);
     }
@@ -118,4 +127,13 @@ public void assertMissing(String value, String... inValues) {
             assertThat(values).doesNotContain(s);
         }
     }
+    
+    public void awaitValueOnce(String value) {
+        awaitValue(null, value);
+        assertThat(values).contains(value);
+        var occurrences = values.stream().filter(e -> value.equals(e)).count();
+        if (occurrences > 1) {
+            fail("Expected " + value + " to be present once but was present " + occurrences + " times.");
+        }
+    }
 }