fixup: using toxiproxy

Signed-off-by: Simon Schrottner <[email protected]>

Author: aepfli

providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/FlagdContainer.java

@@ -4,6 +4,9 @@
 import com.github.dockerjava.api.command.SyncDockerCmd;
 import com.github.dockerjava.api.command.UnpauseContainerCmd;
 import dev.openfeature.contrib.providers.flagd.Config;
+import java.io.File;
+import java.nio.file.Files;
+import java.util.List;
 import org.apache.logging.log4j.util.Strings;
 import org.jetbrains.annotations.NotNull;
 import org.testcontainers.containers.GenericContainer;
@@ -42,33 +45,18 @@ public FlagdContainer(String feature) {
         super(generateContainerName(feature));
         this.withReuse(true);
         this.feature = feature;
-        if (!"socket".equals(this.feature))
-            this.addExposedPorts(8013, 8014, 8015, 8016);
-    }
-
-
-    public int getPort(Config.Resolver resolver) {
-        waitUntilContainerStarted();
-        switch (resolver) {
-            case RPC:
-                return this.getMappedPort(8013);
-            case IN_PROCESS:
-                return this.getMappedPort(8015);
-            default:
-                throw new IllegalArgumentException("Unsupported resolver: " + resolver);
-        }
+        if (!"socket".equals(this.feature)) this.addExposedPorts(8013, 8014, 8015, 8016);
     }
 
-
     /**
      * @return a {@link org.testcontainers.containers.GenericContainer} instance of envoy container using
      * flagd sync service as backend expose on port 9211
      */
     public static GenericContainer envoy() {
         final String container = "envoyproxy/envoy:v1.31.0";
         return new GenericContainer(DockerImageName.parse(container))
-                .withCopyFileToContainer(MountableFile.forClasspathResource("/envoy-config/envoy-custom.yaml"),
-                        "/etc/envoy/envoy.yaml")
+                .withCopyFileToContainer(
+                        MountableFile.forClasspathResource("/envoy-config/envoy-custom.yaml"), "/etc/envoy/envoy.yaml")
                 .withExposedPorts(9211)
                 .withNetwork(network)
                 .withNetworkAliases("envoy");

providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/RunInProcessTest.java

@@ -1,7 +1,10 @@
 package dev.openfeature.contrib.providers.flagd.e2e;
 
+import static io.cucumber.junit.platform.engine.Constants.GLUE_PROPERTY_NAME;
+import static io.cucumber.junit.platform.engine.Constants.OBJECT_FACTORY_PROPERTY_NAME;
+import static io.cucumber.junit.platform.engine.Constants.PLUGIN_PROPERTY_NAME;
+
 import dev.openfeature.contrib.providers.flagd.Config;
-import io.cucumber.junit.platform.engine.Constants;
 import org.apache.logging.log4j.core.config.Order;
 import org.junit.platform.suite.api.BeforeSuite;
 import org.junit.platform.suite.api.ConfigurationParameter;
@@ -12,10 +15,6 @@
 import org.junit.platform.suite.api.Suite;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
-import static io.cucumber.junit.platform.engine.Constants.GLUE_PROPERTY_NAME;
-import static io.cucumber.junit.platform.engine.Constants.OBJECT_FACTORY_PROPERTY_NAME;
-import static io.cucumber.junit.platform.engine.Constants.PLUGIN_PROPERTY_NAME;
-
 /**
  * Class for running the reconnection tests for the RPC provider
  */
@@ -36,4 +35,3 @@ public static void before() {
         State.resolverType = Config.Resolver.IN_PROCESS;
     }
 }
-

providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/RunRpcTest.java

@@ -1,34 +1,33 @@
 package dev.openfeature.contrib.providers.flagd.e2e;
 
+import static io.cucumber.junit.platform.engine.Constants.GLUE_PROPERTY_NAME;
+import static io.cucumber.junit.platform.engine.Constants.OBJECT_FACTORY_PROPERTY_NAME;
+import static io.cucumber.junit.platform.engine.Constants.PLUGIN_PROPERTY_NAME;
+
 import dev.openfeature.contrib.providers.flagd.Config;
-import io.cucumber.junit.platform.engine.Constants;
 import org.apache.logging.log4j.core.config.Order;
 import org.junit.platform.suite.api.BeforeSuite;
 import org.junit.platform.suite.api.ConfigurationParameter;
 import org.junit.platform.suite.api.ExcludeTags;
 import org.junit.platform.suite.api.IncludeEngines;
 import org.junit.platform.suite.api.IncludeTags;
-import org.junit.platform.suite.api.SelectDirectories;
+import org.junit.platform.suite.api.SelectFile;
 import org.junit.platform.suite.api.SelectFile;
 import org.junit.platform.suite.api.Suite;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
-import static io.cucumber.junit.platform.engine.Constants.GLUE_PROPERTY_NAME;
-import static io.cucumber.junit.platform.engine.Constants.OBJECT_FACTORY_PROPERTY_NAME;
-import static io.cucumber.junit.platform.engine.Constants.PLUGIN_PROPERTY_NAME;
-
 /**
  * Class for running the reconnection tests for the RPC provider
  */
 @Order(value = Integer.MAX_VALUE)
 @Suite
 @IncludeEngines("cucumber")
-//@SelectDirectories("test-harness/gherkin")
+// @SelectDirectories("test-harness/gherkin")
 @SelectFile("test-harness/gherkin/connection.feature")
 @ConfigurationParameter(key = PLUGIN_PROPERTY_NAME, value = "pretty")
 @ConfigurationParameter(key = GLUE_PROPERTY_NAME, value = "dev.openfeature.contrib.providers.flagd.e2e.steps")
 @ConfigurationParameter(key = OBJECT_FACTORY_PROPERTY_NAME, value = "io.cucumber.picocontainer.PicoFactory")
-@IncludeTags({"rpc","reconnect"})
+@IncludeTags({"rpc", "reconnect"})
 @ExcludeTags({"targetURI", "customCert", "unixsocket"})
 @Testcontainers
 public class RunRpcTest {
@@ -37,6 +36,4 @@ public class RunRpcTest {
     public static void before() {
         State.resolverType = Config.Resolver.RPC;
     }
-
 }
-

providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/State.java

@@ -8,8 +8,8 @@
 import dev.openfeature.sdk.Client;
 import dev.openfeature.sdk.FlagEvaluationDetails;
 import dev.openfeature.sdk.MutableContext;
-
-import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Optional;
@@ -20,12 +20,9 @@ public class State {
     public List<Event> events = new LinkedList<>();
     public Optional<Event> lastEvent;
     public FlagSteps.Flag flag;
-    public MutableContext context
-            = new MutableContext();
+    public MutableContext context = new MutableContext();
     public FlagEvaluationDetails evaluation;
     public FlagdOptions options;
     public FlagdOptions.FlagdOptionsBuilder builder = FlagdOptions.builder();
     public static Config.Resolver resolverType;
-
-
 }

providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/steps/AbstractSteps.java

@@ -4,6 +4,7 @@
 
 abstract class AbstractSteps {
     State state;
+
     public AbstractSteps(State state) {
         this.state = state;
     }

providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/steps/ConfigSteps.java

@@ -14,12 +14,9 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
 public class ConfigSteps extends AbstractSteps {
     /**
      * Not all properties are correctly implemented, hence that we need to ignore them till this is
@@ -34,7 +31,6 @@ public class ConfigSteps extends AbstractSteps {
 
     private static final Logger LOG = LoggerFactory.getLogger(ConfigSteps.class);
 
-
     public ConfigSteps(State state) {
         super(state);
     }
@@ -48,7 +44,8 @@ public void we_initialize_a_config() {
     public void we_initialize_a_config_for(String string) {
         switch (string.toLowerCase()) {
             case "in-process":
-                state.options = state.builder.resolverType(Config.Resolver.IN_PROCESS).build();
+                state.options =
+                        state.builder.resolverType(Config.Resolver.IN_PROCESS).build();
                 break;
             case "rpc":
                 state.options = state.builder.resolverType(Config.Resolver.RPC).build();
@@ -84,7 +81,6 @@ public void we_have_an_environment_variable_with_value(String varName, String va
         EnvironmentVariableUtils.set(varName, value);
     }
 
-
     @Then("the option {string} of type {string} should have the value {string}")
     public void the_option_of_type_should_have_the_value(String option, String type, String value) throws Throwable {
         Object convert = Utils.convert(value, type);

providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/steps/ContextSteps.java

@@ -5,24 +5,20 @@
 import dev.openfeature.sdk.MutableContext;
 import dev.openfeature.sdk.Value;
 import io.cucumber.java.en.Given;
-import org.junit.jupiter.api.parallel.Isolated;
-
 import java.util.HashMap;
 import java.util.Map;
-
-import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+import org.junit.jupiter.api.parallel.Isolated;
 
 @Isolated()
 public class ContextSteps extends AbstractSteps {
 
-
     public ContextSteps(State state) {
         super(state);
     }
 
-
     @Given("a context containing a key {string}, with type {string} and with value {string}")
-    public void a_context_containing_a_key_with_type_and_with_value(String key, String type, String value) throws ClassNotFoundException, InstantiationException {
+    public void a_context_containing_a_key_with_type_and_with_value(String key, String type, String value)
+            throws ClassNotFoundException, InstantiationException {
         Map<String, Value> map = state.context.asMap();
         map.put(key, new Value(value));
         state.context = new MutableContext(state.context.getTargetingKey(), map);
@@ -34,10 +30,10 @@ public void a_context_containing_a_targeting_key_with_value(String string) {
     }
 
     @Given("a context containing a nested property with outer key {string} and inner key {string}, with value {string}")
-    public void a_context_containing_a_nested_property_with_outer_key_and_inner_key_with_value(String outer, String inner, String value) {
+    public void a_context_containing_a_nested_property_with_outer_key_and_inner_key_with_value(
+            String outer, String inner, String value) {
         Map<String, Value> innerMap = new HashMap<>();
         innerMap.put(inner, new Value(value));
         state.context.add(outer, new ImmutableStructure(innerMap));
     }
-
 }

providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/steps/EventSteps.java

@@ -1,10 +1,14 @@
 package dev.openfeature.contrib.providers.flagd.e2e.steps;
 
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.awaitility.Awaitility.await;
+
 import dev.openfeature.contrib.providers.flagd.e2e.State;
 import dev.openfeature.sdk.ProviderEvent;
 import io.cucumber.java.en.Given;
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
+import java.util.LinkedList;
 import org.jetbrains.annotations.NotNull;
 import org.junit.jupiter.api.parallel.Isolated;
 import org.slf4j.Logger;
@@ -20,7 +24,6 @@
 public class EventSteps extends AbstractSteps {
     private static final Logger LOG = LoggerFactory.getLogger(EventSteps.class);
 
-
     public EventSteps(State state) {
         super(state);
         state.events = new LinkedList<>();
@@ -62,10 +65,11 @@ public void eventHandlerShouldBeExecuted(String eventType) {
     @Then("the {} event handler should have been executed within {int}ms")
     public void eventHandlerShouldBeExecutedWithin(String eventType, int ms) {
         LOG.info("waiting for eventtype: {}", eventType);
-        await()
-                .atMost(ms, MILLISECONDS)
+        await().atMost(ms, MILLISECONDS)
                 .until(() -> state.events.stream().anyMatch(event -> event.type.equals(eventType)));
-        state.lastEvent = state.events.stream().filter(event -> event.type.equals(eventType)).findFirst();
+        state.lastEvent = state.events.stream()
+                .filter(event -> event.type.equals(eventType))
+                .findFirst();
         state.events.removeIf(event -> event.type.equals(eventType));
     }
 }

providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/e2e/steps/FlagSteps.java

@@ -1,5 +1,7 @@
 package dev.openfeature.contrib.providers.flagd.e2e.steps;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 import dev.openfeature.contrib.providers.flagd.e2e.State;
 import dev.openfeature.sdk.FlagEvaluationDetails;
 import dev.openfeature.sdk.Value;
@@ -8,41 +10,41 @@
 import io.cucumber.java.en.When;
 import org.junit.jupiter.api.parallel.Isolated;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
-
 @Isolated()
 public class FlagSteps extends AbstractSteps {
 
-
     public FlagSteps(State state) {
         super(state);
     }
 
     @Given("a {}-flag with key {string} and a default value {string}")
     public void givenAFlag(String type, String name, String defaultValue) throws ClassNotFoundException {
         state.flag = new Flag(type, name, Utils.convert(defaultValue, type));
-
     }
 
     @When("the flag was evaluated with details")
     public void the_flag_was_evaluated_with_details() {
         FlagEvaluationDetails details;
         switch (state.flag.type) {
             case "String":
-                details = state.client.getStringDetails(state.flag.name, (String) state.flag.defaultValue, state.context);
+                details =
+                        state.client.getStringDetails(state.flag.name, (String) state.flag.defaultValue, state.context);
                 break;
             case "Boolean":
-                details = state.client.getBooleanDetails(state.flag.name, (Boolean) state.flag.defaultValue, state.context);
+                details = state.client.getBooleanDetails(
+                        state.flag.name, (Boolean) state.flag.defaultValue, state.context);
                 break;
             case "Float":
-                details = state.client.getDoubleDetails(state.flag.name, (Double) state.flag.defaultValue, state.context);
+                details =
+                        state.client.getDoubleDetails(state.flag.name, (Double) state.flag.defaultValue, state.context);
                 break;
             case "Integer":
-                details = state.client.getIntegerDetails(state.flag.name, (Integer) state.flag.defaultValue, state.context);
+                details = state.client.getIntegerDetails(
+                        state.flag.name, (Integer) state.flag.defaultValue, state.context);
                 break;
             case "Object":
-                details = state.client.getObjectDetails(state.flag.name, (Value) state.flag.defaultValue, state.context);
+                details =
+                        state.client.getObjectDetails(state.flag.name, (Value) state.flag.defaultValue, state.context);
                 break;
             default:
                 throw new AssertionError();
@@ -59,10 +61,12 @@ public void the_resolved_details_value_should_be(String value) throws ClassNotFo
     public void the_reason_should_be(String reason) {
         assertThat(state.evaluation.getReason()).isEqualTo(reason);
     }
+
     @Then("the variant should be {string}")
     public void the_variant_should_be(String variant) {
         assertThat(state.evaluation.getVariant()).isEqualTo(variant);
     }
+
     @Then("the flag was modified")
     public void the_flag_was_modified() {
         assertThat(state.lastEvent).isPresent().hasValueSatisfying((event) -> {
@@ -71,7 +75,6 @@ public void the_flag_was_modified() {
         });
     }
 
-
     public class Flag {
         String name;
         Object defaultValue;