test: Test for breaking changes

.github/workflows/pullrequest.yml

@@ -45,7 +45,10 @@ jobs:
                 ${{ runner.os }}${{ matrix.build.java }}-maven-
 
       - name: Verify with Maven
-        run: mvn --batch-mode --update-snapshots --activate-profiles e2e,${{ matrix.build.profile }} verify
+        run: mvn --batch-mode --update-snapshots --activate-profiles e2e,${{ matrix.build.profile }} install
+
+      - name: Verify no breaking changes
+        run: mvn verify
 
       - if: matrix.build.java == '17'
         name: Upload coverage to Codecov

pom.xml

@@ -203,6 +203,13 @@
             <scope>test</scope>
         </dependency>
 
+        <dependency>
+            <groupId>dev.openfeature.contrib.providers</groupId>
+            <artifactId>flagd</artifactId>
+            <version>0.11.18</version>
+            <scope>test</scope>
+        </dependency>
+
     </dependencies>
 
     <dependencyManagement>

src/main/java/dev/openfeature/sdk/EventProvider.java

@@ -112,7 +112,7 @@ public Awaitable emit(final ProviderEvent event, final ProviderEventDetails deta
      *
      * @param details The details of the event
      */
-    public Awaitable emitProviderReady(ProviderEventDetails details) {
+    /*public*/ Awaitable emitProviderReady(ProviderEventDetails details) {
         return emit(ProviderEvent.PROVIDER_READY, details);
     }
 

src/test/java/dev/openfeature/sdk/DeveloperExperienceTest.java

@@ -176,7 +176,7 @@
             text =
                     "If the provider emits an event, the value of the client's provider status MUST be updated accordingly.")
     @Test
     void shouldPutTheProviderInStateReadyAfterEmittingReadyEvent() {
         String domain = "domain";
         var provider = TestProvider.builder().initsToReady();
         api.setProviderAndWait(domain, provider);
@@ -184,7 +184,7 @@
         assertThat(client.getProviderState()).isEqualTo(ProviderState.READY);
         provider.emitProviderStale(ProviderEventDetails.builder().build()).await();
         assertThat(client.getProviderState()).isEqualTo(ProviderState.STALE);
-        provider.emitProviderReady(ProviderEventDetails.builder().build()).await();
-        assertThat(client.getProviderState()).isEqualTo(ProviderState.READY);
+        // provider.emitProviderReady(ProviderEventDetails.builder().build()).await();
+        // assertThat(client.getProviderState()).isEqualTo(ProviderState.READY);
     }
 }

src/test/java/dev/openfeature/sdk/NoBreakingChangesTest.java

@@ -0,0 +1,88 @@
+package dev.openfeature.sdk;
+
+import dev.openfeature.contrib.providers.flagd.Config;
+import dev.openfeature.contrib.providers.flagd.FlagdOptions;
+import dev.openfeature.contrib.providers.flagd.FlagdProvider;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashSet;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class NoBreakingChangesTest {
+
+    private AtomicBoolean isTestRunning;
+    private ConcurrentLinkedQueue<Throwable> uncaughtExceptions;
+    private Thread threadWatcher;
+
+    @BeforeEach
+    void setup() {
+        final var isRunning = new AtomicBoolean(true);
+        final var uncaught = new ConcurrentLinkedQueue<Throwable>();
+        uncaughtExceptions = uncaught;
+        isTestRunning = isRunning;
+
+        threadWatcher = new Thread(() -> {
+            var seenThreads = new HashSet<Thread>();
+            while (isRunning.get()) {
+                var stacks = Thread.getAllStackTraces();
+                for (var entry : stacks.entrySet()) {
+                    var thread = entry.getKey();
+                    if (seenThreads.add(thread)) {
+                        thread.setUncaughtExceptionHandler((thread1, throwable) -> {
+                            uncaught.add(throwable);
+                        });
+                    }
+                }
+            }
+        });
+        threadWatcher.setDaemon(true);
+        threadWatcher.start();
+    }
+
+    @AfterEach
+    void teardown() throws InterruptedException {
+        try {
+            Thread.sleep(1000); // wait a bit for any uncaught exceptions to be reported
+
+            isTestRunning.set(false);
+            threadWatcher.join(1000);
+        } finally {
+            assertThat(uncaughtExceptions).isEmpty();
+        }
+    }
+
+    @Test
+    void noBreakingChanges() {
+        var testProvider = new FlagdProvider(FlagdOptions.builder()
+                .resolverType(Config.Resolver.FILE)
+                .offlineFlagSourcePath(NoBreakingChangesTest.class
+                        .getResource("/testFlags.json")
+                        .getPath()
+                        .replaceFirst("/", ""))
+                .build());
+        var api = new OpenFeatureAPI();
+        api.setProviderAndWait(testProvider);
+
+        var client = api.getClient();
+        var flagFound = client.getBooleanDetails("basic-boolean", false);
+        assertThat(flagFound).isNotNull();
+        assertThat(flagFound.getValue()).isTrue();
+        assertThat(flagFound.getVariant()).isEqualTo("true");
+        assertThat(flagFound.getReason()).isEqualTo(Reason.STATIC.toString());
+
+        var flagNotFound = client.getStringDetails("unknown", "asd");
+        assertThat(flagNotFound).isNotNull();
+        assertThat(flagNotFound.getValue()).isEqualTo("asd");
+        assertThat(flagNotFound.getVariant()).isNull();
+        assertThat(flagNotFound.getReason()).isEqualTo(Reason.ERROR.toString());
+        assertThat(flagNotFound.getErrorCode()).isEqualTo(ErrorCode.FLAG_NOT_FOUND);
+
+        testProvider.shutdown();
+        api.shutdown();
+    }
+}

src/test/java/dev/openfeature/sdk/e2e/steps/ProviderSteps.java

@@ -112,11 +112,11 @@
         switch (providerState) {
             case FATAL:
             case ERROR:
-                mockProvider.emitProviderReady(details).await();
+                //  mockProvider.emitProviderReady(details).await();
                 mockProvider.emitProviderError(details).await();
                 break;
             case STALE:
-                mockProvider.emitProviderReady(details).await();
+                //  mockProvider.emitProviderReady(details).await();
                 mockProvider.emitProviderStale(details).await();
                 break;
             default:

src/test/java/dev/openfeature/sdk/testutils/TestStackedEmitCallsProvider.java

@@ -5,7 +5,6 @@
 import dev.openfeature.sdk.Metadata;
 import dev.openfeature.sdk.ProviderEvaluation;
 import dev.openfeature.sdk.ProviderEvent;
-import dev.openfeature.sdk.ProviderEventDetails;
 import dev.openfeature.sdk.Value;
 import java.util.function.Consumer;
 
@@ -38,7 +37,7 @@
                  * This line deadlocked in the original implementation without the emitterExecutor see
                  * https://github.com/open-feature/java-sdk/issues/1299
                  */
-                emitProviderReady(ProviderEventDetails.builder().build());
+                // emitProviderReady(ProviderEventDetails.builder().build());
             }
         }
     }

src/test/resources/testFlags.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://flagd.dev/schema/v0/flags.json",
+  "flags": {
+    "basic-boolean": {
+      "state": "ENABLED",
+      "defaultVariant": "true",
+      "variants": {
+        "true": true,
+        "false": false
+      },
+      "targeting": {}
+    }
+  }
+}