Fix: client breaks when evaluation contains segments or unknown response fields

src/main/java/com/octopus/openfeature/provider/FeatureToggleEvaluation.java

@@ -3,23 +3,27 @@
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 
+import java.util.Collections;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
 
 class FeatureToggleEvaluation {
     private final String name;
     private final String slug;
     private final boolean isEnabled;
-    private final List<Map.Entry<String, String>> segments;
+    private final List<Segment> segments;
 
     @JsonCreator(mode = JsonCreator.Mode.PROPERTIES)
-    FeatureToggleEvaluation(@JsonProperty("name") String name, @JsonProperty("slug")String slug, @JsonProperty("isEnabled") boolean isEnabled,
-                            @JsonProperty("segments") List<Map.Entry<String, String>> segments) {
+    FeatureToggleEvaluation(
+        @JsonProperty("name") String name,
+        @JsonProperty("slug") String slug,
+        @JsonProperty("isEnabled") boolean isEnabled,
+        @JsonProperty("segments") List<Segment> segments
+    ) {
         this.name = name;
         this.slug = slug;
         this.isEnabled = isEnabled;
-        
+
         this.segments = new ArrayList<>();
         if (segments != null) {
             this.segments.addAll(segments);
@@ -38,7 +42,7 @@ public boolean isEnabled() {
         return isEnabled;
     }
 
-    public List<Map.Entry<String, String>> getSegments() {
-        return segments;
+    public List<Segment> getSegments() {
+        return Collections.unmodifiableList(segments);
     }
 }

src/main/java/com/octopus/openfeature/provider/OctopusClient.java

@@ -36,7 +36,7 @@ Boolean haveFeatureTogglesChanged(byte[] contentHash)
                 .build();
         try {
             HttpResponse<String> httpResponse = client.send(request, HttpResponse.BodyHandlers.ofString());
-            FeatureToggleCheckResponse checkResponse = new ObjectMapper().readValue(httpResponse.body(), FeatureToggleCheckResponse.class);
+            FeatureToggleCheckResponse checkResponse = OctopusObjectMapper.INSTANCE.readValue(httpResponse.body(), FeatureToggleCheckResponse.class);
             return !Arrays.equals(checkResponse.contentHash, contentHash);
         } catch (Exception e) {
             logger.log(System.Logger.Level.WARNING, String.format("Unable to query Octopus Feature Toggle service. URI: %s", checkURI.toString()), e);
@@ -65,7 +65,7 @@ FeatureToggles getFeatureToggleEvaluationManifest()
                 logger.log(System.Logger.Level.WARNING,String.format("Feature toggle response from %s did not contain expected ContentHash header", manifestURI.toString()));      
                 return null;
             }
-            List<FeatureToggleEvaluation> evaluations = new ObjectMapper().readValue(httpResponse.body(), new TypeReference<List<FeatureToggleEvaluation>>(){}); 
+            List<FeatureToggleEvaluation> evaluations = OctopusObjectMapper.INSTANCE.readValue(httpResponse.body(), new TypeReference<List<FeatureToggleEvaluation>>(){}); 
             return new FeatureToggles(evaluations, Base64.getDecoder().decode(contentHashHeader.get()));
         } catch (Exception e) {
             logger.log(System.Logger.Level.WARNING, "Unable to query Octopus Feature Toggle service", e);

src/main/java/com/octopus/openfeature/provider/OctopusContext.java

@@ -48,13 +48,13 @@ ProviderEvaluation<Boolean> evaluate(String slug, Boolean defaultValue, Evaluati
                 .build();
     }
 
-    private Boolean MatchesSegment(EvaluationContext evaluationContext, List<Map.Entry<String, String>> segments) {
+    private Boolean MatchesSegment(EvaluationContext evaluationContext, List<Segment> segments) {
         if (evaluationContext == null) {
             return false;
         }
 
         var contextEntries = evaluationContext.asMap();
-        var groupedByKey = segments.stream().collect(groupingBy(Map.Entry::getKey));
+        var groupedByKey = segments.stream().collect(groupingBy(Segment::getKey));
         return groupedByKey.keySet().stream().allMatch(k -> {
             var values = groupedByKey.get(k);
 

src/main/java/com/octopus/openfeature/provider/OctopusObjectMapper.java

@@ -0,0 +1,13 @@
+package com.octopus.openfeature.provider;
+
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.MapperFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.json.JsonMapper;
+
+class OctopusObjectMapper {
+    static final ObjectMapper INSTANCE = JsonMapper.builder()
+            .enable(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES)
+            .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
+            .build();
+}

src/main/java/com/octopus/openfeature/provider/Segment.java

@@ -0,0 +1,26 @@
+package com.octopus.openfeature.provider;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+class Segment {
+    private final String key;
+    private final String value;
+
+    @JsonCreator(mode = JsonCreator.Mode.PROPERTIES)
+    public Segment(
+        @JsonProperty(value = "key", required = true) String key,
+        @JsonProperty(value = "value", required = true) String value
+    ) {
+        this.key = key;
+        this.value = value;
+    }
+
+    public String getKey() {
+        return key;
+    }
+
+    public String getValue() {
+        return value;
+    }
+}

src/test/java/com/octopus/openfeature/provider/FeatureToggleEvaluationDeserializationTests.java

@@ -0,0 +1,129 @@
+package com.octopus.openfeature.provider;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.exc.MismatchedInputException;
+import org.junit.jupiter.api.Test;
+
+import java.io.InputStream;
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class FeatureToggleEvaluationDeserializationTests {
+
+    private final ObjectMapper objectMapper = OctopusObjectMapper.INSTANCE;
+
+    private InputStream resource(String name) {
+        return getClass().getResourceAsStream(name);
+    }
+
+    private void assertSegmentsContain(List<Segment> segments, Segment... expected) {
+        assertThat(segments).usingRecursiveFieldByFieldElementComparator().contains(expected);
+    }
+
+    @Test
+    void shouldDeserializeEnabledToggle() throws Exception {
+        FeatureToggleEvaluation result = objectMapper.readValue(resource("toggle-enabled-no-segments.json"), FeatureToggleEvaluation.class);
+
+        assertThat(result.getName()).isEqualTo("My Feature");
+        assertThat(result.getSlug()).isEqualTo("my-feature");
+        assertThat(result.isEnabled()).isTrue();
+        assertThat(result.getSegments()).isEmpty();
+    }
+
+    @Test
+    void shouldDeserializeDisabledToggle() throws Exception {
+        FeatureToggleEvaluation result = objectMapper.readValue(resource("toggle-disabled.json"), FeatureToggleEvaluation.class);
+
+        assertThat(result.isEnabled()).isFalse();
+    }
+
+    @Test
+    void shouldDeserializeToggleWithMissingSegmentsField() throws Exception {
+        FeatureToggleEvaluation result = objectMapper.readValue(resource("toggle-missing-segments.json"), FeatureToggleEvaluation.class);
+
+        assertThat(result.getSegments()).isNotNull().isEmpty();
+    }
+
+    @Test
+    void shouldDeserializeToggleWithSegments() throws Exception {
+        FeatureToggleEvaluation result = objectMapper.readValue(
+                resource("toggle-with-segments.json"), FeatureToggleEvaluation.class);
+
+        assertThat(result.getSegments()).hasSize(2);
+        assertSegmentsContain(result.getSegments(),
+                new Segment("license-type", "free"),
+                new Segment("country", "au")
+        );
+    }
+
+    @Test
+    void shouldDeserializeListOfToggles() throws Exception {
+        List<FeatureToggleEvaluation> result = objectMapper.readValue(
+                resource("toggle-list.json"),
+                new TypeReference<>() {
+                }
+        );
+
+        assertThat(result).hasSize(2);
+        assertThat(result.get(0).getSlug()).isEqualTo("feature-a");
+        assertThat(result.get(0).isEnabled()).isTrue();
+        assertThat(result.get(1).getSlug()).isEqualTo("feature-b");
+        assertThat(result.get(1).isEnabled()).isFalse();
+    }
+
+    @Test
+    void shouldDeserializeListOfTogglesWithVariousFieldCasings() throws Exception {
+        List<FeatureToggleEvaluation> result = objectMapper.readValue(
+                resource("toggles-with-different-field-capitalisation.json"),
+                new TypeReference<>() {
+                }
+        );
+
+        assertThat(result).hasSize(3);
+        assertThat(result.get(0).getSlug()).isEqualTo("feature-a");
+        assertThat(result.get(0).isEnabled()).isTrue();
+        assertSegmentsContain(result.get(0).getSegments(), new Segment("license-type", "free"));
+        assertThat(result.get(1).getSlug()).isEqualTo("feature-b");
+        assertThat(result.get(1).isEnabled()).isTrue();
+        assertSegmentsContain(result.get(1).getSegments(), new Segment("plan", "enterprise"));
+        assertThat(result.get(2).getSlug()).isEqualTo("feature-c");
+        assertThat(result.get(2).isEnabled()).isTrue();
+        assertSegmentsContain(result.get(2).getSegments(), new Segment("country", "au"));
+    }
+
+    @Test
+    void shouldFailDeserializationWhenSegmentKeyIsMissing() {
+        assertThatThrownBy(() -> objectMapper.readValue(
+                resource("toggle-segment-missing-key.json"), FeatureToggleEvaluation.class))
+                .isInstanceOf(MismatchedInputException.class);
+    }
+
+    @Test
+    void shouldFailDeserializationWhenSegmentValueIsMissing() {
+        assertThatThrownBy(() -> objectMapper.readValue(
+                resource("toggle-segment-missing-value.json"), FeatureToggleEvaluation.class))
+                .isInstanceOf(MismatchedInputException.class);
+    }
+
+    @Test
+    void shouldFailDeserializationWhenSegmentKeyAndValueAreMissing() {
+        assertThatThrownBy(() -> objectMapper.readValue(
+                resource("toggle-segment-missing-key-and-value.json"), FeatureToggleEvaluation.class))
+                .isInstanceOf(MismatchedInputException.class);
+    }
+
+    @Test
+    void shouldIgnoreExtraneousProperties() throws Exception {
+        FeatureToggleEvaluation result = objectMapper.readValue(
+                resource("toggle-with-extraneous-properties.json"), FeatureToggleEvaluation.class);
+
+        assertThat(result.getName()).isEqualTo("My Feature");
+        assertThat(result.getSlug()).isEqualTo("my-feature");
+        assertThat(result.isEnabled()).isTrue();
+        assertSegmentsContain(result.getSegments(), new Segment("license-type", "free"));
+    }
+}

src/test/java/com/octopus/openfeature/provider/OctopusContextTests.java

@@ -20,7 +20,7 @@ class OctopusContextTests {
             Arrays.asList(
                     new FeatureToggleEvaluation("Enabled Feature", "enabled-feature", true, null),
                     new FeatureToggleEvaluation("Disabled Feature", "disabled-feature", false, null),
-                    new FeatureToggleEvaluation("Feature With Segments", "feature-with-segments", true, Arrays.asList(Map.entry("license-type", "free"), Map.entry("country", "au")) )
+                    new FeatureToggleEvaluation("Feature With Segments", "feature-with-segments", true, Arrays.asList(new Segment("license-type", "free"), new Segment("country", "au")) )
             ),
             new byte[0]
     );

src/test/resources/com/octopus/openfeature/provider/toggle-disabled.json

@@ -0,0 +1,6 @@
+{
+  "name": "My Feature",
+  "slug": "my-feature",
+  "isEnabled": false,
+  "segments": null
+}

src/test/resources/com/octopus/openfeature/provider/toggle-enabled-no-segments.json

@@ -0,0 +1,6 @@
+{
+  "name": "My Feature",
+  "slug": "my-feature",
+  "isEnabled": true,
+  "segments": null
+}

src/test/resources/com/octopus/openfeature/provider/toggle-list.json

@@ -0,0 +1,14 @@
+[
+  {
+    "name": "Feature A",
+    "slug": "feature-a",
+    "isEnabled": true,
+    "segments": null
+  },
+  {
+    "name": "Feature B",
+    "slug": "feature-b",
+    "isEnabled": false,
+    "segments": null
+  }
+]

src/test/resources/com/octopus/openfeature/provider/toggle-missing-segments.json

@@ -0,0 +1,5 @@
+{
+  "name": "My Feature",
+  "slug": "my-feature",
+  "isEnabled": true
+}

src/test/resources/com/octopus/openfeature/provider/toggle-segment-missing-key-and-value.json

@@ -0,0 +1,8 @@
+{
+  "name": "My Feature",
+  "slug": "my-feature",
+  "isEnabled": true,
+  "segments": [
+    {}
+  ]
+}

src/test/resources/com/octopus/openfeature/provider/toggle-segment-missing-key.json

@@ -0,0 +1,10 @@
+{
+  "name": "My Feature",
+  "slug": "my-feature",
+  "isEnabled": true,
+  "segments": [
+    {
+      "value": "free"
+    }
+  ]
+}

src/test/resources/com/octopus/openfeature/provider/toggle-segment-missing-value.json

@@ -0,0 +1,10 @@
+{
+  "name": "My Feature",
+  "slug": "my-feature",
+  "isEnabled": true,
+  "segments": [
+    {
+      "key": "license-type"
+    }
+  ]
+}

src/test/resources/com/octopus/openfeature/provider/toggle-with-extraneous-properties.json

@@ -0,0 +1,17 @@
+{
+  "name": "My Feature",
+  "slug": "my-feature",
+  "isEnabled": true,
+  "segments": [
+    {
+      "key": "license-type",
+      "value": "free",
+      "more": "data"
+    }
+  ],
+  "foo": "bar",
+  "qux": 123,
+  "wux": {
+    "nested": "value"
+  }
+}

src/test/resources/com/octopus/openfeature/provider/toggle-with-segments.json

@@ -0,0 +1,15 @@
+{
+  "name": "My Feature",
+  "slug": "my-feature",
+  "isEnabled": true,
+  "segments": [
+    {
+      "key": "license-type",
+      "value": "free"
+    },
+    {
+      "key": "country",
+      "value": "au"
+    }
+  ]
+}

src/test/resources/com/octopus/openfeature/provider/toggles-with-different-field-capitalisation.json

@@ -0,0 +1,35 @@
+[
+  {
+    "NAME": "Feature A",
+    "SLUG": "feature-a",
+    "ISENABLED": true,
+    "SEGMENTS": [
+      {
+        "KEY": "license-type",
+        "VALUE": "free"
+      }
+    ]
+  },
+  {
+    "Name": "Feature B",
+    "Slug": "feature-b",
+    "IsEnabled": true,
+    "Segments": [
+      {
+        "Key": "plan",
+        "Value": "enterprise"
+      }
+    ]
+  },
+  {
+    "nAmE": "Feature C",
+    "sLuG": "feature-c",
+    "iSeNaBlEd": true,
+    "sEgMeNtS": [
+      {
+        "kEy": "country",
+        "vAlUe": "au"
+      }
+    ]
+  }
+]