Migrate feature-flagging groovy tests to java

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/java/com/datadog/featureflag/FeatureFlaggingSystemTest.java

@@ -0,0 +1,64 @@
+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.AfterEach;
+import org.junit.jupiter.api.Test;
+
+class FeatureFlaggingSystemTest {
+
+  @AfterEach
+  void stopFeatureFlaggingSystem() {
+    FeatureFlaggingSystem.stop();
+  }
+
+  @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);
+
+    assertThrows(
+        IllegalStateException.class, () -> FeatureFlaggingSystem.start(sharedCommunicationObjects));
+  }
+}

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

@@ -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/src/test/java/datadog/trace/api/featureflag/FeatureFlaggingGatewayTest.java

@@ -0,0 +1,83 @@
+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 {
+
+  @BeforeEach
+  @AfterEach
+  void resetCurrentConfiguration() {
+    FeatureFlaggingGateway.dispatch((ServerConfiguration) null);
+  }
+
+  @Test
+  void testAttachingAConfigListener() {
+    FeatureFlaggingGateway.ConfigListener listener =
+        mock(FeatureFlaggingGateway.ConfigListener.class);
+    ServerConfiguration first = mock(ServerConfiguration.class);
+    ServerConfiguration second = mock(ServerConfiguration.class);
+
+    try {
+      FeatureFlaggingGateway.addConfigListener(listener);
+      FeatureFlaggingGateway.dispatch(first);
+
+      verify(listener).accept(first);
+      verifyNoMoreInteractions(listener);
+
+      FeatureFlaggingGateway.dispatch(second);
+
+      verify(listener).accept(second);
+      verifyNoMoreInteractions(listener);
+    } finally {
+      FeatureFlaggingGateway.removeConfigListener(listener);
+    }
+  }
+
+  @Test
+  void testAttachingAListenerAfterConfigured() {
+    FeatureFlaggingGateway.ConfigListener listener =
+        mock(FeatureFlaggingGateway.ConfigListener.class);
+    ServerConfiguration first = mock(ServerConfiguration.class);
+
+    try {
+      FeatureFlaggingGateway.dispatch(first);
+      FeatureFlaggingGateway.addConfigListener(listener);
+
+      verify(listener).accept(first);
+      verifyNoMoreInteractions(listener);
+    } finally {
+      FeatureFlaggingGateway.removeConfigListener(listener);
+    }
+  }
+
+  @Test
+  void testAttachingAnExposureListener() {
+    FeatureFlaggingGateway.ExposureListener listener =
+        mock(FeatureFlaggingGateway.ExposureListener.class);
+    ExposureEvent first = mock(ExposureEvent.class);
+    ExposureEvent second = mock(ExposureEvent.class);
+
+    try {
+      FeatureFlaggingGateway.addExposureListener(listener);
+      FeatureFlaggingGateway.dispatch(first);
+
+      verify(listener).accept(first);
+      verifyNoMoreInteractions(listener);
+
+      FeatureFlaggingGateway.dispatch(second);
+
+      verify(listener).accept(second);
+      verifyNoMoreInteractions(listener);
+    } finally {
+      FeatureFlaggingGateway.removeExposureListener(listener);
+    }
+  }
+}