Add springboot smoke tests for the open feature SDK

Author: manuel-alvarez-alvarez

.github/CODEOWNERS

@@ -142,6 +142,7 @@ dd-trace-core/src/test/groovy/datadog/trace/llmobs/ @DataDog/ml-observability
 
 
 # @DataDog/feature-flagging-and-experimentation-sdk
+/dd-smoke-tests/openfeature-sdk/ @DataDog/feature-flagging-and-experimentation-sdk
 /internal-api/src/main/java/datadog/trace/api/featureflag/ @DataDog/feature-flagging-and-experimentation-sdk
 /internal-api/src/test/groovy/datadog/trace/api/featureflag/ @DataDog/feature-flagging-and-experimentation-sdk
 /dd-java-agent/agent-feature-flagging/ @DataDog/feature-flagging-and-experimentation-sdk

dd-smoke-tests/openfeature-sdk/build.gradle

@@ -0,0 +1,37 @@
+import org.springframework.boot.gradle.tasks.bundling.BootJar
+
+plugins {
+ id 'java'
+ id 'org.springframework.boot' version '2.7.15'
+ id 'io.spring.dependency-management' version '1.0.15.RELEASE'
+}
+
+ext {
+ minJavaVersionForTests = JavaVersion.VERSION_11
+}
+
+apply from: "$rootDir/gradle/java.gradle"
+apply from: "$rootDir/gradle/spring-boot-plugin.gradle"
+description = 'Open Feature provider Smoke Tests.'
+
+tasks.named("compileJava", JavaCompile) {
+ configureCompiler(it, 11, JavaVersion.VERSION_11)
+}
+
+dependencies {
+ implementation project(':products:openfeature')
+ implementation 'org.springframework.boot:spring-boot-starter-web'
+
+ testImplementation project(':dd-smoke-tests')
+}
+
+tasks.withType(Test).configureEach {
+ dependsOn "bootJar"
+ def bootJarTask = tasks.named('bootJar', BootJar)
+ jvmArgumentProviders.add(new CommandLineArgumentProvider() {
+ @Override
+ Iterable<String> asArguments() {
+ return bootJarTask.map { ["-Ddatadog.smoketest.springboot.shadowJar.path=${it.archiveFile.get()}"] }.get()
+ }
+ })
+}

dd-smoke-tests/openfeature-sdk/src/main/java/datadog/smoketest/springboot/SpringbootApplication.java

@@ -0,0 +1,12 @@
+package datadog.smoketest.springboot;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class SpringbootApplication {
+
+ public static void main(final String[] args) {
+ SpringApplication.run(SpringbootApplication.class, args);
+ }
+}

dd-smoke-tests/openfeature-sdk/src/main/java/datadog/smoketest/springboot/openfeature/OpenFeatureConfiguration.java

@@ -0,0 +1,18 @@
+package datadog.smoketest.springboot.openfeature;
+
+import datadog.trace.api.openfeature.Provider;
+import dev.openfeature.sdk.Client;
+import dev.openfeature.sdk.OpenFeatureAPI;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class OpenFeatureConfiguration {
+
+ @Bean
+ public Client openFeatureClient() {
+ OpenFeatureAPI api = OpenFeatureAPI.getInstance();
+ api.setProviderAndWait(new Provider());
+ return api.getClient();
+ }
+}

dd-smoke-tests/openfeature-sdk/src/main/java/datadog/smoketest/springboot/openfeature/OpenFeatureController.java

@@ -0,0 +1,160 @@
+package datadog.smoketest.springboot.openfeature;
+
+import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE;
+
+import dev.openfeature.sdk.Client;
+import dev.openfeature.sdk.EvaluationContext;
+import dev.openfeature.sdk.FlagEvaluationDetails;
+import dev.openfeature.sdk.MutableContext;
+import dev.openfeature.sdk.Structure;
+import dev.openfeature.sdk.Value;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/openfeature")
+public class OpenFeatureController {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(OpenFeatureController.class);
+
+ private final Client client;
+
+ public OpenFeatureController(final Client client) {
+ this.client = client;
+ }
+
+ @PostMapping(
+ value = "/evaluate",
+ consumes = APPLICATION_JSON_VALUE,
+ produces = APPLICATION_JSON_VALUE)
+ public ResponseEntity<?> evaluate(@RequestBody final EvaluateRequest request) {
+ try {
+ final EvaluationContext context = context(request);
+ FlagEvaluationDetails<?> details;
+ switch (request.getVariationType()) {
+ case "BOOLEAN":
+ details =
+ client.getBooleanDetails(
+ request.getFlag(), (Boolean) request.getDefaultValue(), context);
+ break;
+ case "STRING":
+ details =
+ client.getStringDetails(
+ request.getFlag(), (String) request.getDefaultValue(), context);
+ break;
+ case "INTEGER":
+ final Number integerEval = (Number) request.getDefaultValue();
+ details = client.getIntegerDetails(request.getFlag(), integerEval.intValue(), context);
+ break;
+ case "NUMERIC":
+ final Number doubleEval = (Number) request.getDefaultValue();
+ details = client.getDoubleDetails(request.getFlag(), doubleEval.doubleValue(), context);
+ break;
+ case "JSON":
+ details =
+ client.getObjectDetails(
+ request.getFlag(), Value.objectToValue(request.getDefaultValue()), context);
+ break;
+ default:
+ throw new IllegalArgumentException(
+ "Unsupported variation type: " + request.getVariationType());
+ }
+
+ final Object value = details.getValue();
+ final Map<String, Object> result = new HashMap<>();
+ result.put("flagKey", details.getFlagKey());
+ result.put("variant", details.getVariant());
+ result.put("reason", details.getReason());
+ result.put("value", value instanceof Value ? context.convertValue((Value) value) : value);
+ result.put("errorCode", details.getErrorCode());
+ result.put("errorMessage", details.getErrorMessage());
+ result.put("flagMetadata", details.getFlagMetadata().asUnmodifiableMap());
+ return ResponseEntity.ok(result);
+ } catch (Throwable e) {
+ LOGGER.error("Error on resolution", e);
+ return ResponseEntity.internalServerError().body(e.getMessage());
+ }
+ }
+
+ private static EvaluationContext context(final EvaluateRequest request) {
+ final MutableContext context = new MutableContext();
+ context.setTargetingKey(request.getTargetingKey());
+ if (request.attributes != null) {
+ request.attributes.forEach(
+ (key, value) -> {
+ if (value instanceof Boolean) {
+ context.add(key, (Boolean) value);
+ } else if (value instanceof Integer) {
+ context.add(key, (Integer) value);
+ } else if (value instanceof Double) {
+ context.add(key, (Double) value);
+ } else if (value instanceof String) {
+ context.add(key, (String) value);
+ } else if (value instanceof Map) {
+ context.add(key, Value.objectToValue(value).asStructure());
+ } else if (value instanceof List) {
+ context.add(key, Value.objectToValue(value).asList());
+ } else {
+ context.add(key, (Structure) null);
+ }
+ });
+ }
+ return context;
+ }
+
+ public static class EvaluateRequest {
+ private String flag;
+ private String variationType;
+ private Object defaultValue;
+ private String targetingKey;
+ private Map<String, Object> attributes;
+
+ public Map<String, Object> getAttributes() {
+ return attributes;
+ }
+
+ public void setAttributes(Map<String, Object> attributes) {
+ this.attributes = attributes;
+ }
+
+ public Object getDefaultValue() {
+ return defaultValue;
+ }
+
+ public void setDefaultValue(Object defaultValue) {
+ this.defaultValue = defaultValue;
+ }
+
+ public String getFlag() {
+ return flag;
+ }
+
+ public void setFlag(String flag) {
+ this.flag = flag;
+ }
+
+ public String getTargetingKey() {
+ return targetingKey;
+ }
+
+ public void setTargetingKey(String targetingKey) {
+ this.targetingKey = targetingKey;
+ }
+
+ public String getVariationType() {
+ return variationType;
+ }
+
+ public void setVariationType(String variationType) {
+ this.variationType = variationType;
+ }
+ }
+}

dd-smoke-tests/openfeature-sdk/src/test/groovy/datadog/smoketest/springboot/OpenFeatureProviderSmokeTest.groovy

@@ -0,0 +1,142 @@
+package datadog.smoketest.springboot
+
+import com.squareup.moshi.Moshi
+import datadog.remoteconfig.Capabilities
+import datadog.remoteconfig.Product
+import datadog.smoketest.AbstractServerSmokeTest
+import datadog.trace.api.openfeature.exposure.dto.ExposuresRequest
+import groovy.json.JsonOutput
+import groovy.json.JsonSlurper
+import java.nio.file.Files
+import java.nio.file.Paths
+import okhttp3.MediaType
+import okhttp3.Request
+import okhttp3.RequestBody
+import okio.Okio
+import spock.lang.Shared
+import spock.util.concurrent.PollingConditions
+
+class OpenFeatureProviderSmokeTest extends AbstractServerSmokeTest {
+
+ @Shared
+ private final rcPayload = new JsonSlurper().parse(fetchResource("config/flags-v1.json")).with { json ->
+ return JsonOutput.toJson(json.data.attributes)
+ }
+
+ @Shared
+ private final moshi = new Moshi.Builder().build().adapter(ExposuresRequest)
+
+ @Shared
+ private final exposurePoll = new PollingConditions(timeout: 5, initialDelay: 0, delay: 0.1D, factor: 2)
+
+ @Override
+ ProcessBuilder createProcessBuilder() {
+ setRemoteConfig("datadog/2/FFE_FLAGS/1/config", rcPayload)
+
+ final springBootShadowJar = System.getProperty("datadog.smoketest.springboot.shadowJar.path")
+ final command = [javaPath()]
+ command.add('-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005')
+ command.addAll(defaultJavaProperties)
+ command.add('-Ddd.trace.debug=true')
+ command.add('-Ddd.remote_config.enabled=true')
+ command.add("-Ddd.remote_config.url=http://localhost:${server.address.port}/v0.7/config".toString())
+ command.addAll(['-jar', springBootShadowJar, "--server.port=${httpPort}".toString()])
+ final builder = new ProcessBuilder(command).directory(new File(buildDirectory))
+ builder.environment().put('DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED', 'true')
+ return builder
+ }
+
+ @Override
+ Closure decodedEvpProxyMessageCallback() {
+ return { String path, byte[] body ->
+ if (!path.contains('api/v2/exposures')) {
+ return null
+ }
+ return moshi.fromJson(Okio.buffer(Okio.source(new ByteArrayInputStream(body))))
+ }
+ }
+
+ void 'test remote config'() {
+ when:
+ final rcRequest = waitForRcClientRequest {req ->
+ decodeProducts(req).find {it == Product.FFE_FLAGS } != null
+ }
+
+ then:
+ final capabilities = decodeCapabilities(rcRequest)
+ hasCapability(capabilities, Capabilities.CAPABILITY_FFE_FLAG_CONFIGURATION_RULES)
+ }
+
+ void 'test open feature evaluation'() {
+ setup:
+ setRemoteConfig("datadog/2/FFE_FLAGS/1/config", rcPayload)
+ final url = "http://localhost:${httpPort}/openfeature/evaluate"
+ final request = new Request.Builder()
+ .url(url)
+ .post(RequestBody.create(MediaType.parse('application/json'), JsonOutput.toJson(testCase)))
+ .build()
+
+ when:
+ final response = client.newCall(request).execute()
+
+ then:
+ response.code() == 200
+ final responseBody = new JsonSlurper().parse(response.body().byteStream())
+ responseBody.value == testCase.result.value
+ responseBody.variant == testCase.result.variant
+ responseBody.flagMetadata?.allocationKey == testCase.result.flagMetadata?.allocationKey
+ if (testCase.result.flagMetadata?.doLog) {
+ waitForEvpProxyMessage(exposurePoll) {
+ final exposure = it.v2 as ExposuresRequest
+ return exposure.exposures.first().with {
+ it.flag.key == testCase.flag && it.subject.id == testCase.targetingKey
+ }
+ }
+ }
+
+ where:
+ testCase << parseTestCases()
+ }
+
+ private static URL fetchResource(final String name) {
+ return Thread.currentThread().getContextClassLoader().getResource(name)
+ }
+
+ private static List<Map<String, Object>> parseTestCases() {
+ final folder = fetchResource('data')
+ final uri = folder.toURI()
+ final testsPath = Paths.get(uri)
+ final files = Files.list(testsPath)
+ .filter(path -> path.toString().endsWith('.json'))
+ final result = []
+ final slurper = new JsonSlurper()
+ files.each {
+ path ->
+ final testCases = slurper.parse(path.toFile()) as List<Map<String, Object>>
+ testCases.eachWithIndex {
+ testCase, index ->
+ testCase.fileName = path.fileName.toString()
+ testCase.index = index
+ }
+ result.addAll(testCases)
+ }
+ return result
+ }
+
+ private static Set<Product> decodeProducts(final Map<String, Object> request) {
+ return request.client.products.collect { Product.valueOf(it)}
+ }
+
+ private static long decodeCapabilities(final Map<String, Object> request) {
+ final clientCapabilities = request.client.capabilities as byte[]
+ long capabilities = 0l
+ for (int i = 0; i < clientCapabilities.length; i++) {
+ capabilities |= (clientCapabilities[i] & 0xFFL) << ((clientCapabilities.length - i - 1) * 8)
+ }
+ return capabilities
+ }
+
+ private static boolean hasCapability(final long capabilities, final long test) {
+ return (capabilities & test) > 0
+ }
+}