chore: fixup format and merge conflicts

Author: nicklasl

openfeature-provider/java/pom.xml

@@ -132,12 +132,6 @@
     </dependency>
 
     <!-- Test dependencies -->
-    <dependency>
-      <groupId>org.slf4j</groupId>
-      <artifactId>slf4j-simple</artifactId>
-      <version>${slf4j.version}</version>
-      <scope>test</scope>
-    </dependency>
     <dependency>
       <groupId>ch.qos.logback</groupId>
       <artifactId>logback-classic</artifactId>

openfeature-provider/java/src/main/java/com/spotify/confidence/DefaultHttpClientFactory.java

@@ -0,0 +1,33 @@
+package com.spotify.confidence;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Default implementation of HttpClientFactory that creates standard HTTP connections.
+ *
+ * <p>This factory:
+ *
+ * <ul>
+ *   <li>Creates HttpURLConnection instances for the given URLs
+ *   <li>Uses default timeouts and settings from the JVM
+ *   <li>Can be extended or replaced for testing or custom behavior
+ * </ul>
+ */
+public class DefaultHttpClientFactory implements HttpClientFactory {
+  private static final Logger logger = LoggerFactory.getLogger(DefaultHttpClientFactory.class);
+
+  @Override
+  public HttpURLConnection create(String url) throws IOException {
+    return (HttpURLConnection) new URL(url).openConnection();
+  }
+
+  @Override
+  public void shutdown() {
+    // HTTP connections are stateless and don't require cleanup
+    logger.debug("DefaultHttpClientFactory shutdown called (no-op for stateless HTTP)");
+  }
+}

openfeature-provider/java/src/main/java/com/spotify/confidence/FlagsAdminStateFetcher.java

@@ -3,7 +3,6 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.HttpURLConnection;
-import java.net.URL;
 import java.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
@@ -26,15 +25,17 @@ class FlagsAdminStateFetcher implements AccountStateProvider {
       "https://confidence-resolver-state-cdn.spotifycdn.com/";
 
   private final String clientSecret;
+  private final HttpClientFactory httpClientFactory;
   // ETag for conditional GETs of resolver state
   private final AtomicReference<String> etagHolder = new AtomicReference<>();
   private final AtomicReference<byte[]> rawResolverStateHolder =
       new AtomicReference<>(
           com.spotify.confidence.flags.admin.v1.ResolverState.newBuilder().build().toByteArray());
   private String accountId = "";
 
-  public FlagsAdminStateFetcher(String clientSecret) {
+  public FlagsAdminStateFetcher(String clientSecret, HttpClientFactory httpClientFactory) {
     this.clientSecret = clientSecret;
+    this.httpClientFactory = httpClientFactory;
   }
 
   public AtomicReference<byte[]> rawStateHolder() {
@@ -64,7 +65,7 @@ private void fetchAndUpdateStateIfChanged() {
     // Build CDN URL using SHA256 hash of client secret
     final var cdnUrl = CDN_BASE_URL + sha256Hex(clientSecret);
     try {
-      final HttpURLConnection conn = (HttpURLConnection) new URL(cdnUrl).openConnection();
+      final HttpURLConnection conn = httpClientFactory.create(cdnUrl);
       final String previousEtag = etagHolder.get();
       if (previousEtag != null) {
         conn.setRequestProperty("if-none-match", previousEtag);

openfeature-provider/java/src/main/java/com/spotify/confidence/GrpcWasmFlagLogger.java

@@ -32,56 +32,36 @@ public class GrpcWasmFlagLogger implements WasmFlagLogger {
   private static final int MAX_FLAG_ASSIGNED_PER_CHUNK = 1000;
   private static final Duration DEFAULT_SHUTDOWN_TIMEOUT = Duration.ofSeconds(10);
   private final InternalFlagLoggerServiceGrpc.InternalFlagLoggerServiceBlockingStub stub;
-  private final String clientSecret;
   private final ExecutorService executorService;
   private final FlagLogWriter writer;
   private final Duration shutdownTimeout;
 
   @VisibleForTesting
   public GrpcWasmFlagLogger(String clientSecret, FlagLogWriter writer) {
-    this.stub = createStub(new DefaultChannelFactory());
-    this.clientSecret = clientSecret;
+    this.stub = createAuthStub(new DefaultChannelFactory(), clientSecret);
     this.executorService = Executors.newCachedThreadPool();
     this.writer = writer;
     this.shutdownTimeout = DEFAULT_SHUTDOWN_TIMEOUT;
   }
 
+  @VisibleForTesting
+  public GrpcWasmFlagLogger(String clientSecret, FlagLogWriter writer, Duration shutdownTimeout) {
+    this.stub = createAuthStub(new DefaultChannelFactory(), clientSecret);
+    this.executorService = Executors.newCachedThreadPool();
+    this.writer = writer;
+    this.shutdownTimeout = shutdownTimeout;
+  }
+
   public GrpcWasmFlagLogger(String clientSecret, ChannelFactory channelFactory) {
-    this.stub = createStub(channelFactory);
-    this.clientSecret = clientSecret;
+    this.stub = createAuthStub(channelFactory, clientSecret);
     this.executorService = Executors.newCachedThreadPool();
     this.shutdownTimeout = DEFAULT_SHUTDOWN_TIMEOUT;
     this.writer =
         request ->
             executorService.submit(
                 () -> {
                   try {
-                    // Create a stub with authorization header interceptor
-                    InternalFlagLoggerServiceGrpc.InternalFlagLoggerServiceBlockingStub
-                        stubWithAuth =
-                            stub.withInterceptors(
-                                new ClientInterceptor() {
-                                  @Override
-                                  public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
-                                      MethodDescriptor<ReqT, RespT> method,
-                                      CallOptions callOptions,
-                                      Channel next) {
-                                    return new ForwardingClientCall.SimpleForwardingClientCall<
-                                        ReqT, RespT>(next.newCall(method, callOptions)) {
-                                      @Override
-                                      public void start(
-                                          Listener<RespT> responseListener, Metadata headers) {
-                                        Metadata.Key<String> authKey =
-                                            Metadata.Key.of(
-                                                "authorization", Metadata.ASCII_STRING_MARSHALLER);
-                                        headers.put(authKey, "ClientSecret " + clientSecret);
-                                        super.start(responseListener, headers);
-                                      }
-                                    };
-                                  }
-                                });
-
-                    stubWithAuth.clientWriteFlagLogs(request);
+                    stub.clientWriteFlagLogs(request);
                     logger.debug(
                         "Successfully sent flag log with {} entries",
                         request.getFlagAssignedCount());
@@ -91,10 +71,10 @@ public void start(
                 });
   }
 
-  private static InternalFlagLoggerServiceGrpc.InternalFlagLoggerServiceBlockingStub createStub(
-      ChannelFactory channelFactory) {
+  private static InternalFlagLoggerServiceGrpc.InternalFlagLoggerServiceBlockingStub createAuthStub(
+      ChannelFactory channelFactory, String clientSecret) {
     final var channel = createConfidenceChannel(channelFactory);
-    return InternalFlagLoggerServiceGrpc.newBlockingStub(channel);
+    return addAuthInterceptor(InternalFlagLoggerServiceGrpc.newBlockingStub(channel), clientSecret);
   }
 
   @Override
@@ -187,7 +167,7 @@ public void writeSync(WriteFlagLogsRequest request) {
 
   private void sendSync(WriteFlagLogsRequest request) {
     try {
-      stub.writeFlagLogs(request);
+      stub.clientWriteFlagLogs(request);
       logger.debug("Synchronously sent flag log with {} entries", request.getFlagAssignedCount());
     } catch (Exception e) {
       logger.error("Failed to write flag logs synchronously", e);
@@ -217,4 +197,28 @@ public void shutdown() {
       Thread.currentThread().interrupt();
     }
   }
+
+  private static InternalFlagLoggerServiceGrpc.InternalFlagLoggerServiceBlockingStub
+      addAuthInterceptor(
+          InternalFlagLoggerServiceGrpc.InternalFlagLoggerServiceBlockingStub stub,
+          String clientSecret) {
+    // Create a stub with authorization header interceptor
+    return stub.withInterceptors(
+        new ClientInterceptor() {
+          @Override
+          public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+              MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+            return new ForwardingClientCall.SimpleForwardingClientCall<ReqT, RespT>(
+                next.newCall(method, callOptions)) {
+              @Override
+              public void start(Listener<RespT> responseListener, Metadata headers) {
+                Metadata.Key<String> authKey =
+                    Metadata.Key.of("authorization", Metadata.ASCII_STRING_MARSHALLER);
+                headers.put(authKey, "ClientSecret " + clientSecret);
+                super.start(responseListener, headers);
+              }
+            };
+          }
+        });
+  }
 }

openfeature-provider/java/src/main/java/com/spotify/confidence/HttpClientFactory.java

@@ -0,0 +1,42 @@
+package com.spotify.confidence;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+
+/**
+ * HttpClientFactory is an advanced/testing hook allowing callers to customize how HTTP connections
+ * are created. The provider will pass the URL that needs to be fetched.
+ *
+ * <p>Implementations may modify request properties, change URLs, or replace the connection creation
+ * mechanism entirely. This is particularly useful for:
+ *
+ * <ul>
+ *   <li>Unit testing: inject mock HTTP responses
+ *   <li>Integration testing: point to local mock HTTP servers
+ *   <li>Production customization: custom timeouts, proxies, headers
+ *   <li>Debugging: add custom logging or request tracking
+ * </ul>
+ *
+ * <p><strong>Lifecycle:</strong> The factory is responsible for managing any resources it creates.
+ * When {@link #shutdown()} is called, it should clean up any resources that were allocated.
+ */
+public interface HttpClientFactory {
+  /**
+   * Creates an HTTP connection for the given URL.
+   *
+   * @param url the URL to connect to (e.g.,
+   *     "https://confidence-resolver-state-cdn.spotifycdn.com/...")
+   * @return a configured HttpURLConnection
+   * @throws IOException if an I/O error occurs while opening the connection
+   */
+  HttpURLConnection create(String url) throws IOException;
+
+  /**
+   * Shuts down this factory and cleans up any resources. This method should be called when the
+   * provider is shutting down to ensure proper resource cleanup.
+   *
+   * <p>Implementations should clean up any resources that were created and wait for them to
+   * terminate gracefully if applicable.
+   */
+  void shutdown();
+}

openfeature-provider/java/src/main/java/com/spotify/confidence/LocalProviderConfig.java

@@ -2,16 +2,27 @@
 
 public class LocalProviderConfig {
   private final ChannelFactory channelFactory;
+  private final HttpClientFactory httpClientFactory;
 
   public LocalProviderConfig() {
-    this(null);
+    this(null, null);
   }
 
   public LocalProviderConfig(ChannelFactory channelFactory) {
+    this(channelFactory, null);
+  }
+
+  public LocalProviderConfig(ChannelFactory channelFactory, HttpClientFactory httpClientFactory) {
     this.channelFactory = channelFactory != null ? channelFactory : new DefaultChannelFactory();
+    this.httpClientFactory =
+        httpClientFactory != null ? httpClientFactory : new DefaultHttpClientFactory();
   }
 
   public ChannelFactory getChannelFactory() {
     return channelFactory;
   }
+
+  public HttpClientFactory getHttpClientFactory() {
+    return httpClientFactory;
+  }
 }

openfeature-provider/java/src/main/java/com/spotify/confidence/OpenFeatureLocalResolveProvider.java

@@ -160,7 +160,7 @@ public OpenFeatureLocalResolveProvider(
       StickyResolveStrategy stickyResolveStrategy) {
     this.clientSecret = clientSecret;
     this.stickyResolveStrategy = stickyResolveStrategy;
-    this.stateProvider = new FlagsAdminStateFetcher(clientSecret);
+    this.stateProvider = new FlagsAdminStateFetcher(clientSecret, config.getHttpClientFactory());
     final var wasmFlagLogger = new GrpcWasmFlagLogger(clientSecret, config.getChannelFactory());
     this.wasmResolveApi = new ThreadLocalSwapWasmResolverApi(wasmFlagLogger, stickyResolveStrategy);
     this.channelFactory = config.getChannelFactory();
@@ -285,12 +285,12 @@ private <T> ProviderEvaluation<T> getCastedEvaluation(
         .build();
   }
 
-    @Override
-    public void shutdown() {
-        state.set(ProviderState.NOT_READY);
-        log.debug("Shutting down scheduled executors");
-        flagsFetcherExecutor.shutdown();
-        logPollExecutor.shutdown();
+  @Override
+  public void shutdown() {
+    state.set(ProviderState.NOT_READY);
+    log.debug("Shutting down scheduled executors");
+    flagsFetcherExecutor.shutdown();
+    logPollExecutor.shutdown();
 
     try {
       if (!flagsFetcherExecutor.awaitTermination(1, TimeUnit.SECONDS)) {

openfeature-provider/java/src/test/java/com/spotify/confidence/CapturingWasmFlagLogger.java

@@ -40,6 +40,11 @@ public void write(WriteFlagLogsRequest request) {
     capturedRequests.add(request);
   }
 
+  @Override
+  public void writeSync(WriteFlagLogsRequest request) {
+    capturedRequests.add(request);
+  }
+
   @Override
   public void shutdown() {
     shutdownCalled = true;