test: Wire wrapper, proxy, context comparison and secure mode hash in the contract test service

lib/sdk/server/contract-tests/service/src/main/java/sdktest/Representations.java

@@ -31,6 +31,8 @@ public static class SdkConfigParams {
     SdkConfigEventParams events;
     SdkConfigBigSegmentsParams bigSegments;
     SdkConfigTagParams tags;
+    SdkConfigWrapperParams wrapper;
+    SdkConfigProxyParams proxy;
     SdkConfigServiceEndpointParams serviceEndpoints;
     SdkConfigHookParams hooks;
     SdkConfigDataSystemParams dataSystem;
@@ -65,6 +67,15 @@ public static class SdkConfigTagParams {
     String applicationVersion;
   }
 
+  public static class SdkConfigWrapperParams {
+    String name;
+    String version;
+  }
+
+  public static class SdkConfigProxyParams {
+    String httpProxy;
+  }
+
   public static class SdkConfigServiceEndpointParams {
     String streaming;
     String polling;
@@ -210,6 +221,7 @@ public static class CommandParams {
     CustomEventParams customEvent;
     ContextBuildParams contextBuild;
     ContextConvertParams contextConvert;
+    ContextComparisonPairParams contextComparison;
     SecureModeHashParams secureModeHash;
 
     MigrationVariationParams migrationVariation;
@@ -332,6 +344,37 @@ public static class ContextBuildResponse {
   public static class ContextConvertParams {
     String input;
   }
+
+  public static class ContextComparisonPairParams {
+    ContextComparisonParams context1;
+    ContextComparisonParams context2;
+  }
+
+  public static class ContextComparisonParams {
+    ContextComparisonSingleParams single;
+    ContextComparisonSingleParams[] multi;
+  }
+
+  public static class ContextComparisonSingleParams {
+    String kind;
+    String key;
+    AttributeDefinition[] attributes;
+    PrivateAttribute[] privateAttributes;
+  }
+
+  public static class AttributeDefinition {
+    String name;
+    LDValue value;
+  }
+
+  public static class PrivateAttribute {
+    String value;
+    boolean literal;
+  }
+
+  public static class ContextComparisonResponse {
+    boolean equals;
+  }
 
   public static class SecureModeHashParams {
     LDContext context;

lib/sdk/server/contract-tests/service/src/main/java/sdktest/SdkClientEntity.java

@@ -1,5 +1,6 @@
 package sdktest;
 
+import com.launchdarkly.sdk.AttributeRef;
 import com.launchdarkly.sdk.ContextBuilder;
 import com.launchdarkly.sdk.ContextMultiBuilder;
 import com.launchdarkly.sdk.EvaluationDetail;
@@ -24,6 +25,7 @@
 import com.launchdarkly.sdk.server.integrations.BigSegmentsConfigurationBuilder;
 import com.launchdarkly.sdk.server.integrations.EventProcessorBuilder;
 import com.launchdarkly.sdk.server.integrations.HooksConfigurationBuilder;
+import com.launchdarkly.sdk.server.integrations.HttpConfigurationBuilder;
 import com.launchdarkly.sdk.server.integrations.ServiceEndpointsBuilder;
 import com.launchdarkly.sdk.server.integrations.StreamingDataSourceBuilder;
 import com.launchdarkly.sdk.server.integrations.PollingDataSourceBuilder;
@@ -42,6 +44,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.net.URI;
 import java.net.URL;
 import java.time.Duration;
 import java.util.ArrayList;
@@ -50,10 +53,15 @@
 import java.util.Map;
 import java.util.Optional;
 
+import sdktest.Representations.AttributeDefinition;
 import sdktest.Representations.CommandParams;
 import sdktest.Representations.ContextBuildParams;
 import sdktest.Representations.ContextBuildResponse;
 import sdktest.Representations.ContextBuildSingleParams;
+import sdktest.Representations.ContextComparisonPairParams;
+import sdktest.Representations.ContextComparisonParams;
+import sdktest.Representations.ContextComparisonResponse;
+import sdktest.Representations.ContextComparisonSingleParams;
 import sdktest.Representations.ContextConvertParams;
 import sdktest.Representations.CreateInstanceParams;
 import sdktest.Representations.CustomEventParams;
@@ -63,6 +71,7 @@
 import sdktest.Representations.EvaluateFlagResponse;
 import sdktest.Representations.GetBigSegmentsStoreStatusResponse;
 import sdktest.Representations.IdentifyEventParams;
+import sdktest.Representations.PrivateAttribute;
 import sdktest.Representations.RegisterFlagChangeListenerParams;
 import sdktest.Representations.RegisterFlagValueChangeListenerParams;
 import sdktest.Representations.UnregisterListenerParams;
@@ -120,6 +129,8 @@ public Object doCommand(CommandParams params) throws TestService.BadRequestExcep
       return doContextBuild(params.contextBuild);
     case "contextConvert":
       return doContextConvert(params.contextConvert);
+    case "contextComparison":
+      return doContextComparison(params.contextComparison);
     case "secureModeHash":
       return doSecureModeHash(params.secureModeHash);
     case "migrationVariation":
@@ -299,6 +310,38 @@ private ContextBuildResponse doContextConvert(ContextConvertParams params) {
     return resp;
   }
 
+  private ContextComparisonResponse doContextComparison(ContextComparisonPairParams params) {
+    ContextComparisonResponse resp = new ContextComparisonResponse();
+    resp.equals = buildComparisonContext(params.context1).equals(buildComparisonContext(params.context2));
+    return resp;
+  }
+
+  private LDContext buildComparisonContext(ContextComparisonParams params) {
+    if (params.single != null) {
+      return buildComparisonSingle(params.single);
+    }
+    ContextMultiBuilder b = LDContext.multiBuilder();
+    for (ContextComparisonSingleParams s : params.multi) {
+      b.add(buildComparisonSingle(s));
+    }
+    return b.build();
+  }
+
+  private LDContext buildComparisonSingle(ContextComparisonSingleParams params) {
+    ContextBuilder b = LDContext.builder(params.key).kind(params.kind);
+    if (params.attributes != null) {
+      for (AttributeDefinition a : params.attributes) {
+        b.set(a.name, a.value);
+      }
+    }
+    if (params.privateAttributes != null) {
+      for (PrivateAttribute p : params.privateAttributes) {
+        b.privateAttributes(p.literal ? AttributeRef.fromLiteral(p.value) : AttributeRef.fromPath(p.value));
+      }
+    }
+    return b.build();
+  }
+
   private SecureModeHashResponse doSecureModeHash(SecureModeHashParams params) {
     SecureModeHashResponse resp = new SecureModeHashResponse();
     resp.result = client.secureModeHash(params.context);
@@ -498,6 +541,20 @@ private LDConfig buildSdkConfig(SdkConfigParams params, String tag) {
 
     builder.serviceEndpoints(endpoints);
 
+    if (params.wrapper != null) {
+      // The harness sends "" for an unset name or version. The SDK treats only null as unset.
+      builder.wrapper(Components.wrapperInfo()
+          .wrapperName(emptyToNull(params.wrapper.name))
+          .wrapperVersion(emptyToNull(params.wrapper.version)));
+    }
+
+    if (params.proxy != null && params.proxy.httpProxy != null) {
+      URI proxyUri = URI.create(params.proxy.httpProxy);
+      HttpConfigurationBuilder http = Components.httpConfiguration()
+          .proxyHostAndPort(proxyUri.getHost(), proxyUri.getPort());
+      builder.http(http);
+    }
+
     if (params.hooks != null && params.hooks.hooks != null) {
       List<Hook> hookList = new ArrayList<>();
       for (HookConfig hookConfig : params.hooks.hooks) {
@@ -646,4 +703,7 @@ private DataSourceBuilder<Synchronizer> createSynchronizer(
     return null;
   }
 
+  private static String emptyToNull(String s) {
+    return s == null || s.isEmpty() ? null : s;
+  }
 }

lib/sdk/server/contract-tests/service/src/main/java/sdktest/TestService.java

@@ -29,6 +29,7 @@ public class TestService {
     "anonymous-redaction",
     "big-segments",
     "client-prereq-events",
+    "context-comparison",
     "context-type",
     "evaluation-hooks",
     "event-gzip",
@@ -37,13 +38,16 @@ public class TestService {
     "flag-change-listeners",
     "flag-value-change-listeners",
     "hook-environment-id",
+    "http-proxy",
     "inline-context-all",
     "migrations",
     "optional-event-gzip",
+    "secure-mode-hash",
     "server-side",
     "service-endpoints",
     "strongly-typed",
     "tags",
+    "wrapper",
     "server-side-polling",
     "polling-gzip",
     "fdv1-fallback",