feat: Add JUnit5 extension for OpenFeature

pom.xml

@@ -28,6 +28,7 @@
 
     <modules>
         <module>hooks/open-telemetry</module>
+        <module>tools/junit-openfeature</module>
         <module>providers/flagd</module>
         <module>providers/flagsmith</module>
         <module>providers/go-feature-flag</module>

tools/junit-openfeature/README.md

@@ -0,0 +1,156 @@
+# JUnit Open Feature extension
+
+A JUnit5 extension to reduce boilerplate code for testing code which utilizes OpenFeature.
+
+## Getting Started
+
+We are supporting two different flavors for testing, a [simple](#simple-configuration) and an [extended](#extended-configuration) configuration.
+
+Notice: We are most likely not multithread compatible!
+### Simple Configuration
+
+Choose the simple configuration if you are only testing in one domain.
+Per default, it will be used in the global domain.
+
+```java
+@Test
+@Flag(name = "BOOLEAN_FLAG", value = "true")
+void test() {
+    // your test code
+}
+``` 
+
+#### Multiple flags
+
+The `@Flag` annotation can be also repeated multiple times.
+
+```java
+@Test
+@Flag(name = "BOOLEAN_FLAG", value = "true")
+@Flag(name = "BOOLEAN_FLAG2", value = "true")
+void test() {
+    // your test code
+}
+``` 
+
+#### Defining Flags for a whole test-class
+
+`@Flags` can be defined on the class-level too, but method-level
+annotations will superseded class-level annotations.
+
+```java
+@Flag(name = "BOOLEAN_FLAG", value = "true")
+@Flag(name = "BOOLEAN_FLAG2", value = "false")
+class Test {
+    @Test
+    @Flag(name = "BOOLEAN_FLAG2", value = "true") // will be used
+    void test() {
+        // your test code
+    }
+}
+``` 
+
+#### Setting a different domain
+
+You can define an own domain on the test-class-level with `@OpenFeatureDefaultDomain` like:
+
+```java
+@OpenFeatureDefaultDomain("domain")
+class Test {
+    @Test
+    @Flag(name = "BOOLEAN_FLAG", value = "true")
+        // this flag will be available in the `domain` domain
+    void test() {
+        // your test code
+    }
+}
+```
+
+### Extended Configuration
+
+Use the extended configuration when your code needs to use multiple domains.
+
+```java
+@Test
+@OpenFeature({
+    @Flag(name = "BOOLEAN_FLAG", value = "true")
+})
+void test() {
+    // your test code
+}
+```
+
+
+#### Multiple flags
+
+The `@Flag` annotation can be also repeated multiple times.
+
+```java
+@Test
+@OpenFeature({
+        @Flag(name = "BOOLEAN_FLAG", value = "true"),
+        @Flag(name = "BOOLEAN_FLAG2", value = "true")
+})
+void test() {
+    // your test code
+}
+``` 
+
+#### Defining Flags for a whole test-class
+
+`@Flags` can be defined on the class-level too, but method-level
+annotations will superseded class-level annotations.
+
+```java
+@OpenFeature({
+        @Flag(name = "BOOLEAN_FLAG", value = "true"),
+        @Flag(name = "BOOLEAN_FLAG2", value = "false")
+})
+class Test {
+    @Test
+    @OpenFeature({
+            @Flag(name = "BOOLEAN_FLAG2", value = "true") // will be used
+    })
+    void test() {
+        // your test code
+    }
+}
+``` 
+
+#### Setting a different domain
+
+You can define an own domain for each usage of the `@OpenFeature` annotation with the `domain` property:
+
+```java
+@Test
+@OpenFeature(
+    domain = "domain",
+    value = {
+        @Flag(name = "BOOLEAN_FLAG2", value = "true") // will be used
+})
+    // this flag will be available in the `domain` domain
+void test() {
+    // your test code
+}
+```
+
+#### Multiple Configurations for multiple domains
+
+Following testcode will generate two providers, with different flag configurations for a test.
+
+```java
+@Test
+@OpenFeature({
+        @Flag(name = "BOOLEAN_FLAG", value = "true"),
+        @Flag(name = "BOOLEAN_FLAG2", value = "true")
+})
+@OpenFeature(
+        domain = "domain",
+        value = {
+            @Flag(name = "BOOLEAN_FLAG2", value = "true") // will be used
+        })
+void test() {
+    // your test code
+}
+``` 
+

tools/junit-openfeature/pom.xml

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>dev.openfeature.contrib</groupId>
+        <artifactId>parent</artifactId>
+        <version>0.1.0</version>
+        <relativePath>../../pom.xml</relativePath>
+    </parent>
+    <groupId>dev.openfeature.contrib.tools</groupId>
+    <artifactId>junitopenfeature</artifactId>
+    <version>0.0.1</version> <!--x-release-please-version -->
+
+    <name>junit-openfeature-extension</name>
+    <description>JUnit5 Extension for OpenFeature</description>
+    <url>https://openfeature.dev</url>
+
+    <developers>
+        <developer>
+            <id>aepfli</id>
+            <name>Simon Schrottner</name>
+            <organization>OpenFeature</organization>
+            <url>https://openfeature.dev/</url>
+        </developer>
+    </developers>
+
+    <dependencies>
+        <dependency>
+            <groupId>dev.openfeature</groupId>
+            <artifactId>sdk</artifactId>
+            <version>[1.4,2.0)</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>${junit.jupiter.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.junit-pioneer</groupId>
+            <artifactId>junit-pioneer</artifactId>
+            <version>1.9.1</version>
+        </dependency>
+    </dependencies>
+
+</project>

tools/junit-openfeature/src/main/java/dev/openfeature/contrib/tools/junitopenfeature/OpenFeatureExtension.java

@@ -0,0 +1,155 @@
+package dev.openfeature.contrib.tools.junitopenfeature;
+
+import dev.openfeature.contrib.tools.junitopenfeature.annotations.OpenFeature;
+import dev.openfeature.contrib.tools.junitopenfeature.annotations.OpenFeatureDefaultDomain;
+import dev.openfeature.sdk.OpenFeatureAPI;
+import dev.openfeature.sdk.providers.memory.Flag;
+import org.apache.commons.lang3.BooleanUtils;
+import org.junit.jupiter.api.extension.AfterEachCallback;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.InvocationInterceptor;
+import org.junit.jupiter.api.extension.ReflectiveInvocationContext;
+import org.junitpioneer.internal.PioneerAnnotationUtils;
+
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * JUnit5 Extension for OpenFeature.
+ */
+public class OpenFeatureExtension implements BeforeEachCallback, AfterEachCallback, InvocationInterceptor {
+
+    OpenFeatureAPI api = OpenFeatureAPI.getInstance();
+
+    private static Map<String, Map<String, Flag<?>>> handleExtendedConfiguration(
+            ExtensionContext extensionContext,
+            Map<String, Map<String, Flag<?>>> configuration
+    ) {
+        PioneerAnnotationUtils
+                .findAllEnclosingRepeatableAnnotations(extensionContext, OpenFeature.class)
+                .forEachOrdered(annotation -> {
+                    Map<String, Flag<?>> domainFlags = configuration.getOrDefault(annotation.domain(), new HashMap<>());
+
+                    Arrays.stream(annotation.value())
+                            .filter(flag -> !domainFlags.containsKey(flag.name()))
+                            .forEach(flag -> {
+                                Flag.FlagBuilder<?> builder = generateFlagBuilder(flag);
+                                domainFlags.put(flag.name(), builder.build());
+                            });
+                    configuration.put(annotation.domain(), domainFlags);
+                });
+        return configuration;
+    }
+
+    private static Map<String, Map<String, Flag<?>>> handleSimpleConfiguration(ExtensionContext extensionContext) {
+        Map<String, Map<String, Flag<?>>> configuration = new HashMap<>();
+        String defaultDomain = PioneerAnnotationUtils
+                .findClosestEnclosingAnnotation(extensionContext, OpenFeatureDefaultDomain.class)
+                .map(OpenFeatureDefaultDomain::value).orElse("");
+        PioneerAnnotationUtils
+                .findAllEnclosingRepeatableAnnotations(
+                        extensionContext,
+                        dev.openfeature.contrib.tools.junitopenfeature.annotations.Flag.class)
+                .forEachOrdered(flag -> {
+                    Map<String, Flag<?>> domainFlags = configuration.getOrDefault(defaultDomain, new HashMap<>());
+                    if (!domainFlags.containsKey(flag.name())) {
+                        Flag.FlagBuilder<?> builder = generateFlagBuilder(flag);
+                        domainFlags.put(flag.name(), builder.build());
+                        configuration.put(defaultDomain, domainFlags);
+                    }
+                });
+
+        return configuration;
+    }
+
+    private static Flag.FlagBuilder<?> generateFlagBuilder(
+            dev.openfeature.contrib.tools.junitopenfeature.annotations.Flag flag
+    ) {
+        Flag.FlagBuilder<?> builder;
+        switch (flag.valueType().getSimpleName()) {
+            case "Boolean":
+                builder = Flag.<Boolean>builder();
+                builder.variant(flag.value(), BooleanUtils.toBoolean(flag.value()));
+                break;
+            case "String":
+                builder = Flag.<String>builder();
+                builder.variant(flag.value(), flag.value());
+                break;
+            case "Integer":
+                builder = Flag.<Integer>builder();
+                builder.variant(flag.value(), Integer.parseInt(flag.value()));
+                break;
+            case "Double":
+                builder = Flag.<Double>builder();
+                builder.variant(flag.value(), Double.parseDouble(flag.value()));
+                break;
+            default:
+                throw new IllegalArgumentException("Unsupported flag type: " + flag.value());
+        }
+        builder.defaultVariant(flag.value());
+        return builder;
+    }
+
+    @Override
+    public void interceptTestMethod(
+            Invocation<Void> invocation,
+            ReflectiveInvocationContext<Method> invocationContext,
+            ExtensionContext extensionContext
+    ) throws Throwable {
+        TestProvider.CURRENT_NAMESPACE.set(getNamespace(extensionContext));
+        invocation.proceed();
+        TestProvider.CURRENT_NAMESPACE.remove();
+    }
+
+    @Override
+    public void afterEach(ExtensionContext extensionContext) throws Exception {
+    }
+
+    @Override
+    public void beforeEach(ExtensionContext extensionContext) throws Exception {
+        Map<String, Map<String, Flag<?>>> configuration = handleSimpleConfiguration(extensionContext);
+        configuration.putAll(handleExtendedConfiguration(extensionContext, configuration));
+
+        for (Map.Entry<String, Map<String, Flag<?>>> stringMapEntry : configuration.entrySet()) {
+
+            if (!stringMapEntry.getKey().isEmpty()) {
+                String domain = stringMapEntry.getKey();
+                if (api.getProvider(domain) instanceof TestProvider && api.getProvider(domain) != api.getProvider()) {
+                    ((TestProvider) api.getProvider(domain))
+                            .addFlags(getNamespace(extensionContext), stringMapEntry.getValue());
+                } else {
+                    api.setProvider(domain, new TestProvider(
+                            getNamespace(extensionContext),
+                            stringMapEntry.getValue()));
+                }
+            } else {
+                if (api.getProvider() instanceof TestProvider) {
+                    ((TestProvider) api.getProvider())
+                            .addFlags(getNamespace(extensionContext), stringMapEntry.getValue());
+                } else {
+                    api.setProvider(new TestProvider(
+                            getNamespace(extensionContext),
+                            stringMapEntry.getValue()));
+                }
+            }
+
+        }
+
+        getStore(extensionContext).put("config", configuration);
+
+    }
+
+    private ExtensionContext.Namespace getNamespace(ExtensionContext extensionContext) {
+        return ExtensionContext.Namespace.create(
+                getClass(),
+                extensionContext.getRequiredTestMethod()
+        );
+    }
+
+    private ExtensionContext.Store getStore(ExtensionContext context) {
+        return context.getStore(ExtensionContext.Namespace.create(getClass()));
+    }
+}