Migrate feature-flagging groovy tests to java (#11716)

Migrate feature-flagging groovy tests to java

Address flaky test

Merge branch 'master' into sarahchen6/migrate-feature-flagging-tests-to-java

Merge branch 'master' into sarahchen6/migrate-feature-flagging-tests-to-java

Merge branch 'master' into sarahchen6/migrate-feature-flagging-tests-to-java

Clean up pt1

Clean up pt2

Clean up pt3

Clean up pt4

Wait for flush in both cases of testFailuresAreRetried

Add VisibleForTesting annotation

Merge branch 'master' into sarahchen6/migrate-feature-flagging-tests-to-java

Merge branch 'master' into sarahchen6/migrate-feature-flagging-tests-to-java

Update to use test-utils polling

Co-authored-by: sarah.chen <sarah.chen@datadoghq.com>

Author: sarahchen6

products/feature-flagging/feature-flagging-agent/build.gradle.kts

@@ -16,6 +16,8 @@ dependencies {
   api(project(":products:feature-flagging:feature-flagging-lib"))
   api(project(":internal-api"))
 
+  testImplementation(libs.bundles.junit5)
+  testImplementation(libs.bundles.mockito)
   testImplementation(project(":utils:test-utils"))
   testRuntimeOnly(project(":dd-trace-core"))
 }

products/feature-flagging/feature-flagging-agent/src/test/groovy/com/datadog/featureflag/FeatureFlaggingSystemTest.groovy

@@ -0,0 +1,63 @@
+package com.datadog.featureflag;
+
+import static datadog.trace.api.config.RemoteConfigConfig.REMOTE_CONFIGURATION_ENABLED;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import datadog.communication.ddagent.DDAgentFeaturesDiscovery;
+import datadog.communication.ddagent.SharedCommunicationObjects;
+import datadog.remoteconfig.Capabilities;
+import datadog.remoteconfig.ConfigurationDeserializer;
+import datadog.remoteconfig.ConfigurationPoller;
+import datadog.remoteconfig.Product;
+import datadog.trace.api.Config;
+import datadog.trace.junit.utils.config.WithConfig;
+import okhttp3.HttpUrl;
+import okhttp3.OkHttpClient;
+import org.junit.jupiter.api.Test;
+
+class FeatureFlaggingSystemTest {
+
+  @Test
+  void testFeatureFlagSystemInitialization() {
+    ConfigurationPoller poller = mock(ConfigurationPoller.class);
+    DDAgentFeaturesDiscovery discovery = mock(DDAgentFeaturesDiscovery.class);
+    SharedCommunicationObjects sharedCommunicationObjects = mock(SharedCommunicationObjects.class);
+    when(discovery.supportsEvpProxy()).thenReturn(true);
+    when(discovery.getEvpProxyEndpoint()).thenReturn("/evp_proxy/");
+    when(sharedCommunicationObjects.configurationPoller(any(Config.class))).thenReturn(poller);
+    when(sharedCommunicationObjects.featuresDiscovery(any(Config.class))).thenReturn(discovery);
+    sharedCommunicationObjects.agentUrl = HttpUrl.get("http://localhost");
+    sharedCommunicationObjects.agentHttpClient = new OkHttpClient.Builder().build();
+
+    FeatureFlaggingSystem.start(sharedCommunicationObjects);
+
+    verify(poller).addCapabilities(Capabilities.CAPABILITY_FFE_FLAG_CONFIGURATION_RULES);
+    verify(poller).addListener(eq(Product.FFE_FLAGS), any(ConfigurationDeserializer.class), any());
+    verify(poller).start();
+
+    FeatureFlaggingSystem.stop();
+
+    verify(poller).removeCapabilities(Capabilities.CAPABILITY_FFE_FLAG_CONFIGURATION_RULES);
+    verify(poller).removeListeners(Product.FFE_FLAGS);
+    verify(poller).stop();
+  }
+
+  @Test
+  @WithConfig(key = REMOTE_CONFIGURATION_ENABLED, value = "false")
+  void testThatRemoteConfigIsRequired() {
+    SharedCommunicationObjects sharedCommunicationObjects = mock(SharedCommunicationObjects.class);
+
+    try {
+      assertThrows(
+          IllegalStateException.class,
+          () -> FeatureFlaggingSystem.start(sharedCommunicationObjects));
+    } finally {
+      FeatureFlaggingSystem.stop();
+    }
+  }
+}

products/feature-flagging/feature-flagging-agent/src/test/java/com/datadog/featureflag/FeatureFlaggingSystemTest.java

@@ -30,5 +30,7 @@ extra["excludedClassesCoverage"] = listOf(
 )
 
 dependencies {
+  testImplementation(libs.bundles.junit5)
+  testImplementation(libs.bundles.mockito)
   testImplementation(project(":utils:test-utils"))
 }

products/feature-flagging/feature-flagging-bootstrap/build.gradle.kts

@@ -0,0 +1,80 @@
+package datadog.trace.api.featureflag;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import datadog.trace.api.featureflag.exposure.ExposureEvent;
+import datadog.trace.api.featureflag.ufc.v1.ServerConfiguration;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class FeatureFlaggingGatewayTest {
+
+  private FeatureFlaggingGateway.ConfigListener configListener;
+  private FeatureFlaggingGateway.ExposureListener exposureListener;
+  private ServerConfiguration firstConfiguration;
+  private ServerConfiguration secondConfiguration;
+  private ExposureEvent firstExposure;
+  private ExposureEvent secondExposure;
+
+  @BeforeEach
+  void setUp() {
+    configListener = mock(FeatureFlaggingGateway.ConfigListener.class);
+    exposureListener = mock(FeatureFlaggingGateway.ExposureListener.class);
+    firstConfiguration = mock(ServerConfiguration.class);
+    secondConfiguration = mock(ServerConfiguration.class);
+    firstExposure = mock(ExposureEvent.class);
+    secondExposure = mock(ExposureEvent.class);
+  }
+
+  @AfterEach
+  void tearDown() {
+    FeatureFlaggingGateway.removeConfigListener(configListener);
+    FeatureFlaggingGateway.removeExposureListener(exposureListener);
+  }
+
+  @Test
+  void testAttachingAConfigListener() {
+    clearCurrentServerConfiguration();
+
+    FeatureFlaggingGateway.addConfigListener(configListener);
+    FeatureFlaggingGateway.dispatch(firstConfiguration);
+
+    verify(configListener).accept(firstConfiguration);
+    verifyNoMoreInteractions(configListener);
+
+    FeatureFlaggingGateway.dispatch(secondConfiguration);
+
+    verify(configListener).accept(secondConfiguration);
+    verifyNoMoreInteractions(configListener);
+  }
+
+  @Test
+  void testAttachingAListenerAfterConfigured() {
+    FeatureFlaggingGateway.dispatch(firstConfiguration);
+    FeatureFlaggingGateway.addConfigListener(configListener);
+
+    verify(configListener).accept(firstConfiguration);
+    verifyNoMoreInteractions(configListener);
+  }
+
+  @Test
+  void testAttachingAnExposureListener() {
+    FeatureFlaggingGateway.addExposureListener(exposureListener);
+    FeatureFlaggingGateway.dispatch(firstExposure);
+
+    verify(exposureListener).accept(firstExposure);
+    verifyNoMoreInteractions(exposureListener);
+
+    FeatureFlaggingGateway.dispatch(secondExposure);
+
+    verify(exposureListener).accept(secondExposure);
+    verifyNoMoreInteractions(exposureListener);
+  }
+
+  private static void clearCurrentServerConfiguration() {
+    FeatureFlaggingGateway.dispatch((ServerConfiguration) null);
+  }
+}

products/feature-flagging/feature-flagging-bootstrap/src/test/groovy/datadog/trace/api/featureflag/FeatureFlaggingGatewayTest.groovy

@@ -16,6 +16,7 @@
 import datadog.trace.api.featureflag.exposure.ExposureEvent;
 import datadog.trace.api.featureflag.exposure.ExposuresRequest;
 import datadog.trace.api.intake.Intake;
+import datadog.trace.api.internal.VisibleForTesting;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -84,6 +85,16 @@ public void accept(final ExposureEvent event) {
     queue.offer(event);
   }
 
+  @VisibleForTesting
+  boolean isSerializerThreadAlive() {
+    return serializerThread.isAlive();
+  }
+
+  @VisibleForTesting
+  int queueSize() {
+    return queue.size();
+  }
+
   private static class ExposureSerializingHandler implements Runnable {
     private final MessagePassingBlockingQueue<ExposureEvent> queue;
     private final long ticksRequiredToFlush;