Refactor ProviderTest to use setProviderAndWait instead of Awaitility

Replace setProvider() + Awaitility polling with setProviderAndWait() in
all four evaluation tests (boolean, string, double, value). This is
cleaner and avoids the need for async waiting entirely.

To support setProviderAndWait() calling initialize(), the mock
LDClientInterface now stubs getFlagTracker(), getDataSourceStatusProvider(),
and isInitialized() so the provider can complete its initialization
lifecycle.

Co-Authored-By: rlamb@launchdarkly.com <kingdewman@gmail.com>

Author: devin-ai-integration[bot]

src/test/java/com/launchdarkly/openfeature/serverprovider/ProviderTest.java

@@ -4,27 +4,28 @@
 import com.launchdarkly.sdk.EvaluationReason;
 import com.launchdarkly.sdk.LDContext;
 import com.launchdarkly.sdk.LDValue;
+import com.launchdarkly.sdk.server.interfaces.DataSourceStatusProvider;
+import com.launchdarkly.sdk.server.interfaces.FlagTracker;
 import com.launchdarkly.sdk.server.interfaces.LDClientInterface;
 import dev.openfeature.sdk.*;
 import org.junit.jupiter.api.Test;
 
 import static org.mockito.Mockito.*;
 
-import org.awaitility.Awaitility;
-
-import java.time.Duration;
-
 import static org.junit.jupiter.api.Assertions.*;
 
-/**
- * Timeout for Awaitility waits. Provider initialization should complete quickly
- * since these tests use a mock client, but we need a non-infinite bound to avoid
- * hanging the build if a bug prevents initialization.
- */
-
 public class ProviderTest {
     LDClientInterface mockedLdClient = mock(LDClientInterface.class);
 
+    {
+        when(mockedLdClient.getFlagTracker()).thenReturn(mock(FlagTracker.class));
+        DataSourceStatusProvider dsp = mock(DataSourceStatusProvider.class);
+        when(dsp.getStatus()).thenReturn(new DataSourceStatusProvider.Status(
+            DataSourceStatusProvider.State.VALID, null, null));
+        when(mockedLdClient.getDataSourceStatusProvider()).thenReturn(dsp);
+        when(mockedLdClient.isInitialized()).thenReturn(true);
+    }
+
     /**
      * This test uses the package private constructor, which means that it does not set
      * wrapper information.
@@ -38,18 +39,13 @@ public void itCanProvideMetadata() {
     }
 
     @Test
-    public void itCanDoABooleanEvaluation() {
+    public void itCanDoABooleanEvaluation() throws Exception {
         EvaluationContext evaluationContext = new ImmutableContext("user-key");
 
         when(mockedLdClient.boolVariationDetail("the-key", LDContext.create("user-key"), false))
                 .thenReturn(EvaluationDetail.fromValue(true, 12, EvaluationReason.fallthrough()));
 
-        OpenFeatureAPI.getInstance().setProvider(ldProvider);
-
-        Awaitility.await().atMost(Duration.ofSeconds(10)).until(() -> OpenFeatureAPI
-                .getInstance()
-                .getClient()
-                .getBooleanValue("the-key", false, evaluationContext));
+        OpenFeatureAPI.getInstance().setProviderAndWait(ldProvider);
 
         assertTrue(OpenFeatureAPI
                 .getInstance()
@@ -67,19 +63,14 @@ public void itCanDoABooleanEvaluation() {
     }
 
     @Test
-    public void itCanDoAStringEvaluation() {
+    public void itCanDoAStringEvaluation() throws Exception {
         EvaluationContext evaluationContext = new ImmutableContext("user-key");
 
         when(mockedLdClient.stringVariationDetail("the-key", LDContext.create("user-key"), "default"))
                 .thenReturn(EvaluationDetail
                         .fromValue("evaluated", 17, EvaluationReason.off()));
 
-        OpenFeatureAPI.getInstance().setProvider(ldProvider);
-
-        Awaitility.await().atMost(Duration.ofSeconds(10)).until(() -> OpenFeatureAPI
-                .getInstance()
-                .getClient()
-                .getStringValue("the-key", "default", evaluationContext).equals("evaluated"));
+        OpenFeatureAPI.getInstance().setProviderAndWait(ldProvider);
 
         assertEquals("evaluated", OpenFeatureAPI
                 .getInstance()
@@ -97,18 +88,13 @@ public void itCanDoAStringEvaluation() {
     }
 
     @Test
-    public void itCanDoADoubleEvaluation() {
+    public void itCanDoADoubleEvaluation() throws Exception {
         EvaluationContext evaluationContext = new ImmutableContext("user-key");
 
         when(mockedLdClient.doubleVariationDetail("the-key", LDContext.create("user-key"), 0.0))
                 .thenReturn(EvaluationDetail.fromValue(1.0, 42, EvaluationReason.targetMatch()));
 
-        OpenFeatureAPI.getInstance().setProvider(ldProvider);
-
-        Awaitility.await().atMost(Duration.ofSeconds(10)).until(() -> OpenFeatureAPI
-                .getInstance()
-                .getClient()
-                .getDoubleValue("the-key", 0.0, evaluationContext) != 0.0);
+        OpenFeatureAPI.getInstance().setProviderAndWait(ldProvider);
 
         assertEquals(1.0, OpenFeatureAPI
                 .getInstance()
@@ -126,7 +112,7 @@ public void itCanDoADoubleEvaluation() {
     }
 
     @Test
-    public void itCanDoAValueEvaluation() {
+    public void itCanDoAValueEvaluation() throws Exception {
         EvaluationContext evaluationContext = new ImmutableContext("user-key");
 
         EvaluationDetail<LDValue> evaluationDetail = EvaluationDetail
@@ -135,13 +121,7 @@ public void itCanDoAValueEvaluation() {
         when(mockedLdClient.jsonValueVariationDetail("the-key", LDContext.create("user-key"), LDValue.ofNull()))
             .thenReturn(evaluationDetail);
 
-        OpenFeatureAPI.getInstance().setProvider(ldProvider);
-
-        Awaitility.await().atMost(Duration.ofSeconds(10)).until(() -> {
-            Value val = OpenFeatureAPI.getInstance().getClient()
-                .getObjectValue("the-key", new Value(), evaluationContext);
-            return val != null && val.asStructure() != null;
-        });
+        OpenFeatureAPI.getInstance().setProviderAndWait(ldProvider);
 
         Value ofValue = OpenFeatureAPI
             .getInstance()