test(flagd): remove dependency and switch to other envvar utils

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

Author: aepfli

pom.xml

@@ -185,20 +185,6 @@
             <scope>test</scope>
         </dependency>
 
-        <dependency>
-            <groupId>uk.org.webcompere</groupId>
-            <artifactId>system-stubs-core</artifactId>
-            <version>2.0.3</version>
-            <scope>test</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>uk.org.webcompere</groupId>
-            <artifactId>system-stubs-jupiter</artifactId>
-            <version>2.1.7</version>
-            <scope>test</scope>
-        </dependency>
-
         <dependency>
             <groupId>io.cucumber</groupId>
             <artifactId>cucumber-java</artifactId>

providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/resolver/grpc/GrpcConnectorTest.java

@@ -37,12 +37,16 @@
 import io.netty.channel.EventLoopGroup;
 import io.netty.channel.epoll.EpollEventLoopGroup;
 import io.netty.channel.unix.DomainSocketAddress;
-import uk.org.webcompere.systemstubs.environment.EnvironmentVariables;
+import org.junitpioneer.jupiter.SetEnvironmentVariable;
 
 class GrpcConnectorTest {
 
+    public static final String HOST = "server.com";
+    public static final int PORT = 4321;
+    public static final String SOCKET_PATH = "/some/other/path";
+
     @ParameterizedTest
-    @ValueSource(ints = { 1, 2, 3 })
+    @ValueSource(ints = {1, 2, 3})
     void validate_retry_calls(int retries) throws Exception {
         final int backoffMs = 100;
 
@@ -136,14 +140,14 @@ void stream_does_not_fail_on_first_error() {
             // pass true in connected lambda
             final GrpcConnector connector = new GrpcConnector(FlagdOptions.builder().build(), cache,
                     () -> {
-                try {
-                    Thread.sleep(100);
-                    return true;
-                } catch (Exception e) {
-                }
-                return false;
-
-            },
+                        try {
+                            Thread.sleep(100);
+                            return true;
+                        } catch (Exception e) {
+                        }
+                        return false;
+
+                    },
                     onConnectionEvent);
 
             assertDoesNotThrow(connector::initialize);
@@ -325,35 +329,33 @@ void host_and_port_arg_should_build_tcp_socket() {
     }
 
     @Test
+    @SetEnvironmentVariable(key = "FLAGD_HOST", value = HOST)
+    @SetEnvironmentVariable(key = "FLAGD_PORT", value = "" + PORT)
     void no_args_host_and_port_env_set_should_build_tcp_socket() throws Exception {
-        final String host = "server.com";
-        final int port = 4321;
-        final String targetUri = String.format("%s:%s", host, port);
+        final String targetUri = String.format("%s:%s", HOST, PORT);
 
-        new EnvironmentVariables("FLAGD_HOST", host, "FLAGD_PORT", String.valueOf(port)).execute(() -> {
-            ServiceGrpc.ServiceBlockingStub mockBlockingStub = mock(ServiceGrpc.ServiceBlockingStub.class);
-            ServiceGrpc.ServiceStub mockStub = createServiceStubMock();
-            NettyChannelBuilder mockChannelBuilder = getMockChannelBuilderSocket();
+        ServiceGrpc.ServiceBlockingStub mockBlockingStub = mock(ServiceGrpc.ServiceBlockingStub.class);
+        ServiceGrpc.ServiceStub mockStub = createServiceStubMock();
+        NettyChannelBuilder mockChannelBuilder = getMockChannelBuilderSocket();
 
-            try (MockedStatic<ServiceGrpc> mockStaticService = mockStatic(ServiceGrpc.class)) {
-                mockStaticService.when(() -> ServiceGrpc.newBlockingStub(any(Channel.class)))
-                        .thenReturn(mockBlockingStub);
-                mockStaticService.when(() -> ServiceGrpc.newStub(any()))
-                        .thenReturn(mockStub);
+        try (MockedStatic<ServiceGrpc> mockStaticService = mockStatic(ServiceGrpc.class)) {
+            mockStaticService.when(() -> ServiceGrpc.newBlockingStub(any(Channel.class)))
+                    .thenReturn(mockBlockingStub);
+            mockStaticService.when(() -> ServiceGrpc.newStub(any()))
+                    .thenReturn(mockStub);
 
-                try (MockedStatic<NettyChannelBuilder> mockStaticChannelBuilder = mockStatic(
-                        NettyChannelBuilder.class)) {
+            try (MockedStatic<NettyChannelBuilder> mockStaticChannelBuilder = mockStatic(
+                    NettyChannelBuilder.class)) {
 
-                    mockStaticChannelBuilder.when(() -> NettyChannelBuilder
-                            .forTarget(anyString())).thenReturn(mockChannelBuilder);
+                mockStaticChannelBuilder.when(() -> NettyChannelBuilder
+                        .forTarget(anyString())).thenReturn(mockChannelBuilder);
 
-                    new GrpcConnector(FlagdOptions.builder().build(), null, null, null);
+                new GrpcConnector(FlagdOptions.builder().build(), null, null, null);
 
-                    // verify host/port matches & called times(= 1 as we rely on reusable channel)
-                    mockStaticChannelBuilder.verify(() -> NettyChannelBuilder.forTarget(targetUri), times(1));
-                }
+                // verify host/port matches & called times(= 1 as we rely on reusable channel)
+                mockStaticChannelBuilder.verify(() -> NettyChannelBuilder.forTarget(targetUri), times(1));
             }
-        });
+        }
     }
 
     /**
@@ -388,7 +390,7 @@ void path_arg_should_build_domain_socket_with_correct_path() {
                     // verify path matches
                     mockStaticChannelBuilder.verify(() -> NettyChannelBuilder
                             .forAddress(argThat((DomainSocketAddress d) -> {
-                                assertEquals(d.path(), path); // path should match
+                                assertEquals(path, d.path()); // path should match
                                 return true;
                             })), times(1));
                 }
@@ -402,42 +404,40 @@ void path_arg_should_build_domain_socket_with_correct_path() {
      */
     @Test
     @EnabledOnOs(OS.LINUX)
+    @SetEnvironmentVariable(key = "FLAGD_SOCKET_PATH", value = SOCKET_PATH)
     void no_args_socket_env_should_build_domain_socket_with_correct_path() throws Exception {
-        final String path = "/some/other/path";
-
-        new EnvironmentVariables("FLAGD_SOCKET_PATH", path).execute(() -> {
-
-            ServiceBlockingStub mockBlockingStub = mock(ServiceBlockingStub.class);
-            ServiceStub mockStub = mock(ServiceStub.class);
-            NettyChannelBuilder mockChannelBuilder = getMockChannelBuilderSocket();
-
-            try (MockedStatic<ServiceGrpc> mockStaticService = mockStatic(ServiceGrpc.class)) {
-                mockStaticService.when(() -> ServiceGrpc.newBlockingStub(any(Channel.class)))
-                        .thenReturn(mockBlockingStub);
-                mockStaticService.when(() -> ServiceGrpc.newStub(any()))
-                        .thenReturn(mockStub);
-
-                try (MockedStatic<NettyChannelBuilder> mockStaticChannelBuilder = mockStatic(
-                        NettyChannelBuilder.class)) {
-
-                    try (MockedConstruction<EpollEventLoopGroup> mockEpollEventLoopGroup = mockConstruction(
-                            EpollEventLoopGroup.class,
-                            (mock, context) -> {
-                            })) {
-                        mockStaticChannelBuilder.when(() -> NettyChannelBuilder
-                                .forAddress(any(DomainSocketAddress.class))).thenReturn(mockChannelBuilder);
-
-                        new GrpcConnector(FlagdOptions.builder().build(), null, null, null);
-
-                        // verify path matches & called times(= 1 as we rely on reusable channel)
-                        mockStaticChannelBuilder.verify(() -> NettyChannelBuilder
-                                .forAddress(argThat((DomainSocketAddress d) -> {
-                                    return d.path() == path;
-                                })), times(1));
-                    }
+
+        ServiceBlockingStub mockBlockingStub = mock(ServiceBlockingStub.class);
+        ServiceStub mockStub = mock(ServiceStub.class);
+        NettyChannelBuilder mockChannelBuilder = getMockChannelBuilderSocket();
+
+        try (MockedStatic<ServiceGrpc> mockStaticService = mockStatic(ServiceGrpc.class)) {
+            mockStaticService.when(() -> ServiceGrpc.newBlockingStub(any(Channel.class)))
+                    .thenReturn(mockBlockingStub);
+            mockStaticService.when(() -> ServiceGrpc.newStub(any()))
+                    .thenReturn(mockStub);
+
+            try (MockedStatic<NettyChannelBuilder> mockStaticChannelBuilder = mockStatic(
+                    NettyChannelBuilder.class)) {
+
+                try (MockedConstruction<EpollEventLoopGroup> mockEpollEventLoopGroup = mockConstruction(
+                        EpollEventLoopGroup.class,
+                        (mock, context) -> {
+                        })) {
+                    mockStaticChannelBuilder.when(() -> NettyChannelBuilder
+                            .forAddress(any(DomainSocketAddress.class))).thenReturn(mockChannelBuilder);
+
+                    new GrpcConnector(FlagdOptions.builder().build(), null, null, null);
+
+                    // verify path matches & called times(= 1 as we rely on reusable channel)
+                    mockStaticChannelBuilder.verify(() -> NettyChannelBuilder
+                            .forAddress(argThat((DomainSocketAddress d) -> {
+                                assertEquals(SOCKET_PATH, d.path()); // path should match
+                                return true;
+                            })), times(1));
                 }
             }
-        });
+        }
     }
 
     @Test