diff --git a/providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/Config.java b/providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/Config.java index 5ca2c2e48..9f7a51dad 100644 --- a/providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/Config.java +++ b/providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/Config.java @@ -11,7 +11,8 @@ @Slf4j public final class Config { static final Resolver DEFAULT_RESOLVER_TYPE = Resolver.RPC; - static final String DEFAULT_PORT = "8013"; + static final String DEFAULT_RPC_PORT = "8013"; + static final String DEFAULT_IN_PROCESS_PORT = "8015"; static final String DEFAULT_TLS = "false"; static final String DEFAULT_HOST = "localhost"; diff --git a/providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/FlagdOptions.java b/providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/FlagdOptions.java index 53b5fcd9a..2f4e20b9d 100644 --- a/providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/FlagdOptions.java +++ b/providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/FlagdOptions.java @@ -14,7 +14,6 @@ import static dev.openfeature.contrib.providers.flagd.Config.DEFAULT_HOST; import static dev.openfeature.contrib.providers.flagd.Config.DEFAULT_MAX_CACHE_SIZE; import static dev.openfeature.contrib.providers.flagd.Config.DEFAULT_MAX_EVENT_STREAM_RETRIES; -import static dev.openfeature.contrib.providers.flagd.Config.DEFAULT_PORT; import static dev.openfeature.contrib.providers.flagd.Config.DEFAULT_TLS; import static dev.openfeature.contrib.providers.flagd.Config.HOST_ENV_VAR_NAME; import static dev.openfeature.contrib.providers.flagd.Config.MAX_CACHE_SIZE_ENV_VAR_NAME; @@ -39,8 +38,7 @@ public class FlagdOptions { /** * flagd resolving type. */ - @Builder.Default - private Config.EvaluatorType resolverType = fromValueProvider(System::getenv); + private Config.EvaluatorType resolverType; /** * flagd connection host. @@ -51,8 +49,7 @@ public class FlagdOptions { /** * flagd connection port. */ - @Builder.Default - private int port = Integer.parseInt(fallBackToEnvOrDefault(PORT_ENV_VAR_NAME, DEFAULT_PORT)); + private int port; /** * Use TLS connectivity. @@ -126,6 +123,22 @@ public class FlagdOptions { */ private OpenTelemetry openTelemetry; + + /** + * Builder overwrite in order to customize the "build" method. + * + * @return the flagd options builder + */ + public static FlagdOptionsBuilder builder() { + return new FlagdOptionsBuilder() { + @Override + public FlagdOptions build() { + prebuild(); + return super.build(); + } + }; + } + /** * Overload default lombok builder. */ @@ -140,5 +153,22 @@ public FlagdOptionsBuilder withGlobalTelemetry(final boolean b) { } return this; } + + void prebuild() { + if (resolverType == null) { + resolverType = fromValueProvider(System::getenv); + } + + if (port == 0) { + port = Integer.parseInt(fallBackToEnvOrDefault(PORT_ENV_VAR_NAME, determineDefaultPortForResolver())); + } + } + + private String determineDefaultPortForResolver() { + if (resolverType.equals(Config.Resolver.RPC)) { + return Config.DEFAULT_RPC_PORT; + } + return Config.DEFAULT_IN_PROCESS_PORT; + } } } diff --git a/providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/FlagdOptionsTest.java b/providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/FlagdOptionsTest.java index a2e626a73..c7d99d981 100644 --- a/providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/FlagdOptionsTest.java +++ b/providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/FlagdOptionsTest.java @@ -1,29 +1,24 @@ package dev.openfeature.contrib.providers.flagd; import io.opentelemetry.api.OpenTelemetry; +import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.mockito.Mockito; import java.util.function.Function; -import static dev.openfeature.contrib.providers.flagd.Config.DEFAULT_CACHE; -import static dev.openfeature.contrib.providers.flagd.Config.DEFAULT_HOST; -import static dev.openfeature.contrib.providers.flagd.Config.DEFAULT_MAX_CACHE_SIZE; -import static dev.openfeature.contrib.providers.flagd.Config.DEFAULT_MAX_EVENT_STREAM_RETRIES; -import static dev.openfeature.contrib.providers.flagd.Config.DEFAULT_PORT; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static dev.openfeature.contrib.providers.flagd.Config.*; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; -public class FlagdOptionsTest { +class FlagdOptionsTest { @Test - public void TestDefaults() { + void TestDefaults() { final FlagdOptions builder = FlagdOptions.builder().build(); assertEquals(DEFAULT_HOST, builder.getHost()); - assertEquals(DEFAULT_PORT, Integer.toString(builder.getPort())); + assertEquals(DEFAULT_RPC_PORT, Integer.toString(builder.getPort())); assertFalse(builder.isTls()); assertNull(builder.getCertPath()); assertNull(builder.getSocketPath()); @@ -33,11 +28,11 @@ public void TestDefaults() { assertNull(builder.getSelector()); assertNull(builder.getOpenTelemetry()); assertNull(builder.getOfflineFlagSourcePath()); - assertEquals(Config.Resolver.RPC, builder.getResolverType()); + assertEquals(Resolver.RPC, builder.getResolverType()); } @Test - public void TestBuilderOptions() { + void TestBuilderOptions() { OpenTelemetry openTelemetry = Mockito.mock(OpenTelemetry.class); FlagdOptions flagdOptions = FlagdOptions.builder() @@ -51,7 +46,7 @@ public void TestBuilderOptions() { .selector("app=weatherApp") .offlineFlagSourcePath("some-path") .openTelemetry(openTelemetry) - .resolverType(Config.Resolver.IN_PROCESS) + .resolverType(Resolver.IN_PROCESS) .build(); assertEquals("https://hosted-flagd", flagdOptions.getHost()); @@ -64,27 +59,27 @@ public void TestBuilderOptions() { assertEquals("app=weatherApp", flagdOptions.getSelector()); assertEquals("some-path", flagdOptions.getOfflineFlagSourcePath()); assertEquals(openTelemetry, flagdOptions.getOpenTelemetry()); - assertEquals(Config.Resolver.IN_PROCESS, flagdOptions.getResolverType()); + assertEquals(Resolver.IN_PROCESS, flagdOptions.getResolverType()); } @Test - public void testValueProviderForEdgeCase_valid() { + void testValueProviderForEdgeCase_valid() { Function valueProvider = s -> "in-process"; - assertEquals(Config.Resolver.IN_PROCESS, Config.fromValueProvider(valueProvider)); + assertEquals(Resolver.IN_PROCESS, Config.fromValueProvider(valueProvider)); valueProvider = s -> "IN-PROCESS"; - assertEquals(Config.Resolver.IN_PROCESS, Config.fromValueProvider(valueProvider)); + assertEquals(Resolver.IN_PROCESS, Config.fromValueProvider(valueProvider)); valueProvider = s -> "rpc"; - assertEquals(Config.Resolver.RPC, Config.fromValueProvider(valueProvider)); + assertEquals(Resolver.RPC, Config.fromValueProvider(valueProvider)); valueProvider = s -> "RPC"; - assertEquals(Config.Resolver.RPC, Config.fromValueProvider(valueProvider)); + assertEquals(Resolver.RPC, Config.fromValueProvider(valueProvider)); } @Test - public void testValueProviderForEdgeCase_invalid() { + void testValueProviderForEdgeCase_invalid() { Function dummy = s -> "some-other"; assertEquals(Config.DEFAULT_RESOLVER_TYPE, Config.fromValueProvider(dummy)); @@ -92,4 +87,64 @@ public void testValueProviderForEdgeCase_invalid() { assertEquals(Config.DEFAULT_RESOLVER_TYPE, Config.fromValueProvider(dummy)); } + @Test + @Disabled("Currently there is no defined way on how to set environment variables for tests") + void testInProcessProviderFromEnv_noPortConfigured_defaultsToCorrectPort() { + FlagdOptions flagdOptions = FlagdOptions.builder().build(); + + assertThat(flagdOptions.getResolverType()).isEqualTo(Resolver.IN_PROCESS); + assertThat(flagdOptions.getPort()).isEqualTo(Integer.parseInt(DEFAULT_IN_PROCESS_PORT)); + } + + @Test + void testInProcessProvider_noPortConfigured_defaultsToCorrectPort() { + FlagdOptions flagdOptions = FlagdOptions.builder() + .resolverType(Resolver.IN_PROCESS) + .build(); + + assertThat(flagdOptions.getResolverType()).isEqualTo(Resolver.IN_PROCESS); + assertThat(flagdOptions.getPort()).isEqualTo(Integer.parseInt(DEFAULT_IN_PROCESS_PORT)); + } + + @Test + @Disabled("Currently there is no defined way on how to set environment variables for tests") + void testInProcessProviderFromEnv_portConfigured_usesConfiguredPort() { + FlagdOptions flagdOptions = FlagdOptions.builder() + .port(1000) + .build(); + + assertThat(flagdOptions.getResolverType()).isEqualTo(Resolver.IN_PROCESS); + assertThat(flagdOptions.getPort()).isEqualTo(1000); + } + + @Test + @Disabled("Currently there is no defined way on how to set environment variables for tests") + void testRpcProviderFromEnv_noPortConfigured_defaultsToCorrectPort() { + FlagdOptions flagdOptions = FlagdOptions.builder().build(); + + assertThat(flagdOptions.getResolverType()).isEqualTo(Resolver.RPC); + assertThat(flagdOptions.getPort()).isEqualTo(Integer.parseInt(DEFAULT_RPC_PORT)); + } + + @Test + void testRpcProvider_noPortConfigured_defaultsToCorrectPort() { + FlagdOptions flagdOptions = FlagdOptions.builder() + .resolverType(Resolver.RPC) + .build(); + + assertThat(flagdOptions.getResolverType()).isEqualTo(Resolver.RPC); + assertThat(flagdOptions.getPort()).isEqualTo(Integer.parseInt(DEFAULT_RPC_PORT)); + } + + @Test + @Disabled("Currently there is no defined way on how to set environment variables for tests") + void testRpcProviderFromEnv_portConfigured_usesConfiguredPort() { + FlagdOptions flagdOptions = FlagdOptions.builder() + .port(1534) + .build(); + + assertThat(flagdOptions.getResolverType()).isEqualTo(Resolver.RPC); + assertThat(flagdOptions.getPort()).isEqualTo(1534); + + } }