README update

Checking dependencies in build action
Configuration of jacoco plugin
Encoding configuration
Code cleanup

Author: jakubmalek

.github/workflows/build.yml

@@ -0,0 +1,38 @@
+name: build
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+permissions:
+  contents: read
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up JDK 11
+      uses: actions/setup-java@v3
+      with:
+        java-version: '11'
+        distribution: 'temurin'
+    - uses: actions/cache@v3
+      id: gradle-cache
+      with:
+        path: |
+          ~/.gradle/caches
+        key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
+    - uses: actions/cache@v3
+      id: gradle-wrapper-cache
+      with:
+        path: |
+          ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradlewrapper-${{ hashFiles('gradle/wrapper/*') }}
+    - name: Build
+      uses: gradle/gradle-build-action@v2
+      with:
+        arguments: build
+    - name: Dependency check
+      uses: gradle/gradle-build-action@v2
+      with:
+        arguments: dependencyCheckAnalyze

.github/workflows/gradle.yml

@@ -1,34 +1,45 @@
 # AssertJ - Async
 
-AssertJ extension for making asynchronous assertions.
+Extension for [AssertJ](https://github.com/assertj/assertj-core) API for making asynchronous assertions.
+
+[![Build Status](https://github.com/Webfleet-Solutions/assertj-async/actions/workflows/build.yml/badge.svg?branch=main)](https://travis-ci.org/Webfleet-Solutions/oauth-java-example)
+[![license](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](https://opensource.org/licenses/MIT)
 
 ## Usage
 
-The entry point for making asynchronous assertion is `AsyncAssertions` class.
+The entry point for making asynchronous assertion is `com.webfleet.assertj.AsyncAssertions` class.
+
+To make the assertion first, you need to specify the timeout for your assertion:
+* `awaitAtMost(Duration.ofSeconds(5))`
+* `awaitAtMost(5, TimeUnit.SECONDS)`
+* `awaitAtMostOneSecond()`
+* `awaitAtMostTwoSeconds()`
+* `awaitAtMostFiveSeconds()`
+* `awaitAtMostFifteenSeconds()`
+* `awaitAtMostThirtySeconds()`
 
-Here is an example of test:
+Now you can optionally configure following parameters:
+* **Check interval** - the time to be waited in between assertion checks:
+  * `.withCheckInterval(Duration.ofMillis(500))`
+  * `.withCheckInterval(500, TimeUnit.MILLISECONDS)`
+  * By default, it's configured to `100ms` 
+* **Wait mutex** - the object to be used for check interval wait logic:
+  * `.usingWaitMutex(mutex)`
+  * It can be used to optimize the wait time with `notifyAll()` call on state change ending the wait and forcing assertion check 
+
+Finally, you can make your assertions by providing lambda consumer function for `SoftAssertions` object:
 ```java
-class AsyncAssertionExampleTest
-{
-    @Test
-    void shouldReceiveChangeMessages() {
-        // given
-        var receivedMessages = new ConcurrentLinkedQueue<String>();
-
-        // when
-        listenToChanges(receivedMessages::offer);
-
-        // then
-        awaitAtMostOneSecond().untilAssertions(async -> async
-            .assertThat(receivedMessages).containsExactly("A", "B", "C"));
-    }
-    
-    private static void listenToChanges(Consumer<String> consumer) {
-        // simulation of asynchronous consumer
-        var scheduler = Executors.newSingleThreadScheduledExecutor();
-        scheduler.schedule(() -> consumer.accept("A"), 100L, TimeUnit.MILLISECONDS);
-        scheduler.schedule(() -> consumer.accept("B"), 200L, TimeUnit.MILLISECONDS);
-        scheduler.schedule(() -> consumer.accept("C"), 300L, TimeUnit.MILLISECONDS);
-    }
-}
-```
+awaitAtMostOneSecond().untilAssertions(async -> {
+        async.assertThat(condition1).isTrue();
+        async.assertThat(condition2).isTrue();
+    });
+```
+
+The assertions will be periodically checked in provided check interval duration until success or exceeding the timeout.
+
+When timeout is exceeded `AssertionError` will be thrown with error from last failed check.
+
+
+## License
+
+This code is licensed under [MIT License.](https://opensource.org/licenses/MIT) 

README.md

@@ -25,6 +25,36 @@ repositories {
     mavenCentral()
 }
 
+contacts {
+    addPerson("[email protected]", delegateClosureOf<Contact> {
+        github = "jakubmalek"
+        moniker = "Jakub Małek"
+        role("owner")
+    })
+}
+
+sourceSets {
+    register("junit4Test") {
+        compileClasspath += sourceSets.main.get().output
+        runtimeClasspath += sourceSets.main.get().output
+    }
+}
+
+configurations {
+    "junit4TestImplementation" {
+        extendsFrom(implementation.get())
+    }
+    "junit4TestAnnotationProcessor"  {
+        extendsFrom(annotationProcessor.get())
+    }
+    "junit4TestRuntimeOnly" {
+        extendsFrom(runtimeOnly.get())
+    }
+}
+
+group to "com.webfleet"
+
+
 dependencies {
     // api
     api("org.assertj", "assertj-core", "[3.23.0,3.24.0[")
@@ -37,18 +67,58 @@ dependencies {
     // test
     testImplementation("org.junit.jupiter", "junit-jupiter", "[5.8.0,6.0.0[")
     testImplementation("org.mockito", "mockito-junit-jupiter", "[4.6.0,5.0.0[")
+
+    // junit4 test used to test optional dependency to opentest4j
+    "junit4TestImplementation"("junit", "junit", "4.13.2")
 }
 
 tasks {
+    withType<JavaCompile> {
+        options.encoding = "UTF-8"
+    }
+    // Test tasks
+    val junit4Test = register<Test>("junit4Test") {
+        group = LifecycleBasePlugin.VERIFICATION_GROUP
+        description = "Test checking compatibility with JUnit4 API"
+        systemProperty("file.encoding", "UTF-8")
+        testLogging {
+            events("passed", "skipped", "failed")
+        }
+        val sourceSet = sourceSets["junit4Test"]
+        testClassesDirs = sourceSet.output.classesDirs
+        classpath = configurations[sourceSet.runtimeClasspathConfigurationName] + sourceSet.output + sourceSets["main"].output
+    }
     test {
         useJUnitPlatform()
+        systemProperty("file.encoding", "UTF-8")
+        finalizedBy(jacocoTestReport)
+        finalizedBy(junit4Test)
+        testLogging {
+            events("passed", "skipped", "failed")
+        }
+    }
+    // Jacoco tasks
+    jacocoTestReport {
+        dependsOn(test)
+        executionData(fileTree(project.buildDir).include("jacoco/*.exec"))
+        finalizedBy(jacocoTestCoverageVerification)
+        reports {
+            html.required to true
+            xml.required to true
+        }
+    }
+    jacocoTestCoverageVerification {
+        executionData(fileTree(project.buildDir).include("jacoco/*.exec"))
+        violationRules {
+            rule {
+                element = "PACKAGE"
+                includes = listOf("com.webfleet.*")
+                limit {
+                    counter = "INSTRUCTION"
+                    value = "COVEREDRATIO"
+                    minimum = "0.8".toBigDecimal()
+                }
+            }
+        }
     }
-}
-
-contacts {
-    addPerson("[email protected]", delegateClosureOf<Contact> {
-        github = "jakubmalek"
-        moniker = "Jakub Małek"
-        role("owner")
-    })
 }

build.gradle.kts

@@ -1,2 +1,2 @@
-group=com.webfleet
-release.scope=major
+org.gradle.caching=true
+release.scope=patch

gradle.properties

@@ -0,0 +1,68 @@
+package com.webfleet.assertj;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.time.Duration;
+import java.util.List;
+
+import org.assertj.core.api.SoftAssertionError;
+import org.junit.Test;
+
+
+/**
+ * Test checking compatibility with JUnit4.
+ */
+public class AsyncAssertionErrorCreatorJUnit4Test
+{
+    private static final AsyncAssertAwaiConfig CONFIG = AsyncAssertAwaiConfig.withTimeout(Duration.ofSeconds(4));
+
+    @Test
+    public void shouldCreateAsyncAssertionErrorForSingleError()
+    {
+        // given
+        final var error = new AssertionError("test");
+
+        // when
+        final var asyncAssertionError = AsyncAssertionErrorCreator.create(CONFIG, error);
+
+        // then
+        assertThat(asyncAssertionError)
+            .isInstanceOf(AssertionError.class)
+            .hasMessage("Async assertion failed after exceeding 4000ms timeout\n"
+                + "test");
+    }
+
+    @Test
+    public void shouldCreateAssertionErrorForSingleSoftAssertionError()
+    {
+        // given
+        final var multiErrors = new SoftAssertionError(List.of("my error"));
+
+        // when
+        final var asyncAssertionError = AsyncAssertionErrorCreator.create(CONFIG, multiErrors);
+
+        // then
+        assertThat(asyncAssertionError)
+            .isInstanceOf(AssertionError.class)
+            .hasMessage("Async assertion failed after exceeding 4000ms timeout\n"
+                + "my error");
+    }
+
+    @Test
+    public void shouldCreateAssertionErrorForMultipleErrors()
+    {
+        // given
+        final var multiErrors = new SoftAssertionError(List.of("error-1", "error-2", "error-3"));
+
+        // when
+        final var asyncAssertionError = AsyncAssertionErrorCreator.create(CONFIG, multiErrors);
+
+        // then
+        assertThat(asyncAssertionError)
+            .isInstanceOf(AssertionError.class)
+            .hasMessage("Async assertion failed after exceeding 4000ms timeout (failures 3)\n"
+                + "-- failure 1 --error-1\n"
+                + "-- failure 2 --error-2\n"
+                + "-- failure 3 --error-3");
+    }
+}

src/junit4Test/java/com/webfleet/assertj/AsyncAssertionErrorCreatorJUnit4Test.java

@@ -59,7 +59,7 @@ public interface AsyncAssert
      * @param unit the time unit of the check interval
      * @return new {@link AsyncAssert} with set check interval
      */
-    default AsyncAssert withWaitInterval(final long checkInterval, @NonNull final TimeUnit unit)
+    default AsyncAssert withCheckInterval(final long checkInterval, @NonNull final TimeUnit unit)
     {
         return withCheckInterval(Duration.ofMillis(unit.toMillis(checkInterval)));
     }

src/main/java/com/webfleet/assertj/AsyncAssert.java

@@ -20,25 +20,25 @@
 @Getter
 @EqualsAndHashCode
 @ToString
-final class AsyncAssertTimeoutCondition
+final class AsyncAssertAwaiConfig
 {
     private static final Duration DEFAULT_CHECK_INTERVAL = Duration.ofMillis(100L);
     private static final Duration DEFAULT_SHORT_CHECK_INTERVAL = Duration.ofMillis(50L);
 
     private final Duration timeout;
     private final Duration checkInterval;
 
-    static AsyncAssertTimeoutCondition withTimeout(@NonNull final Duration timeout)
+    static AsyncAssertAwaiConfig withTimeout(@NonNull final Duration timeout)
     {
         if (timeout.compareTo(ZERO) <= 0)
         {
             throw new IllegalArgumentException("timeout must be greater than zero");
         }
         final var checkInterval = computeCheckInterval(timeout);
-        return new AsyncAssertTimeoutCondition(timeout, checkInterval);
+        return new AsyncAssertAwaiConfig(timeout, checkInterval);
     }
 
-    AsyncAssertTimeoutCondition withCheckInterval(@NonNull final Duration checkInterval)
+    AsyncAssertAwaiConfig withCheckInterval(@NonNull final Duration checkInterval)
     {
         if (checkInterval.compareTo(ZERO) <= 0)
         {
@@ -48,15 +48,15 @@ AsyncAssertTimeoutCondition withCheckInterval(@NonNull final Duration checkInter
         {
             throw new IllegalArgumentException("checkInterval must be lower than or equal to timeout");
         }
-        return new AsyncAssertTimeoutCondition(timeout, checkInterval);
+        return new AsyncAssertAwaiConfig(timeout, checkInterval);
     }
 
     Duration checkInterval(@NonNull final ElapsedTime elapsedTime)
     {
-        final var elaspsedDuration = elapsedTime.get();
-        if (elaspsedDuration.plus(checkInterval).compareTo(timeout) > 0)
+        final var elapsedDuration = elapsedTime.get();
+        if (elapsedDuration.plus(checkInterval).compareTo(timeout) > 0)
         {
-            final var shortenedCheckInterval = timeout.minus(elaspsedDuration);
+            final var shortenedCheckInterval = timeout.minus(elapsedDuration);
             return shortenedCheckInterval.isNegative() ? Duration.ZERO : shortenedCheckInterval;
         }
         return checkInterval;