Self review

Author: liamhughes

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

@@ -5,9 +5,11 @@
 import com.fasterxml.jackson.core.JsonParser;
 import com.fasterxml.jackson.core.StreamReadFeature;
 import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.JsonDeserializer;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.json.JsonMapper;
 import dev.openfeature.sdk.Client;
 import dev.openfeature.sdk.ErrorCode;
 import dev.openfeature.sdk.EvaluationContext;
@@ -65,41 +67,43 @@ void evaluate(String fileName, String description, String responseJson, FixtureC
 
         EvaluationContext ctx = buildContext(testCase.configuration.context);
         FlagEvaluationDetails<Boolean> result = client.getBooleanDetails(
-            testCase.configuration.slug,
-            testCase.configuration.defaultValue,
-            ctx
+                testCase.configuration.slug,
+                testCase.configuration.defaultValue,
+                ctx
         );
 
         assertThat(result.getValue())
-            .as("[%s] %s → value", fileName, description)
-            .isEqualTo(testCase.expected.value);
+                .as("[%s] %s → value", fileName, description)
+                .isEqualTo(testCase.expected.value);
         assertThat(result.getErrorCode())
-            .as("[%s] %s → errorCode", fileName, description)
-            .isEqualTo(mapErrorCode(testCase.expected.errorCode));
+                .as("[%s] %s → errorCode", fileName, description)
+                .isEqualTo(mapErrorCode(testCase.expected.errorCode));
     }
 
     static Stream<Arguments> fixtureTestCases() throws IOException {
-        ObjectMapper mapper = new ObjectMapper(
-            JsonFactory.builder().enable(StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION).build()
-        );
+        ObjectMapper mapper = JsonMapper.builder()
+                .enable(StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION)
+                .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
+                .build();
+
         List<Path> jsonFiles;
         try (Stream<Path> files = Files.list(Path.of("specification", "Fixtures"))) {
             jsonFiles = files
-                .filter(p -> p.getFileName().toString().endsWith(".json"))
-                .collect(Collectors.toList());
+                    .filter(p -> p.getFileName().toString().endsWith(".json"))
+                    .collect(Collectors.toList());
         }
         if (jsonFiles.isEmpty()) {
             throw new IllegalStateException(
-                "No fixture files found under 'specification/Fixtures/'. " +
-                "Ensure the git submodule is initialised: git submodule update --init");
+                    "No fixture files found under 'specification/Fixtures/'. " +
+                            "Ensure the git submodule is initialised: git submodule update --init");
         }
         return jsonFiles.stream().flatMap(path -> {
             try {
                 String fileContent = Files.readString(path);
                 Fixture fixture = mapper.readValue(fileContent, Fixture.class);
                 String fileName = path.getFileName().toString();
                 return Stream.of(fixture.cases)
-                    .map(c -> Arguments.of(fileName, c.description, fixture.response, c));
+                        .map(c -> Arguments.of(fileName, c.description, fixture.response, c));
             } catch (IOException e) {
                 throw new UncheckedIOException(e);
             }
@@ -117,50 +121,53 @@ private static EvaluationContext buildContext(Map<String, String> context) {
     private static ErrorCode mapErrorCode(String code) {
         if (code == null) return null;
         switch (code) {
-            case "FLAG_NOT_FOUND":       return ErrorCode.FLAG_NOT_FOUND;
-            case "PARSE_ERROR":          return ErrorCode.PARSE_ERROR;
-            case "TYPE_MISMATCH":        return ErrorCode.TYPE_MISMATCH;
-            case "TARGETING_KEY_MISSING": return ErrorCode.TARGETING_KEY_MISSING;
-            case "PROVIDER_NOT_READY":   return ErrorCode.PROVIDER_NOT_READY;
-            case "INVALID_CONTEXT":      return ErrorCode.INVALID_CONTEXT;
-            case "PROVIDER_FATAL":       return ErrorCode.PROVIDER_FATAL;
-            case "GENERAL":              return ErrorCode.GENERAL;
-            default: throw new IllegalArgumentException("Unknown error code in fixture: " + code);
+            case "FLAG_NOT_FOUND":
+                return ErrorCode.FLAG_NOT_FOUND;
+            case "PARSE_ERROR":
+                return ErrorCode.PARSE_ERROR;
+            case "TYPE_MISMATCH":
+                return ErrorCode.TYPE_MISMATCH;
+            case "TARGETING_KEY_MISSING":
+                return ErrorCode.TARGETING_KEY_MISSING;
+            case "PROVIDER_NOT_READY":
+                return ErrorCode.PROVIDER_NOT_READY;
+            case "INVALID_CONTEXT":
+                return ErrorCode.INVALID_CONTEXT;
+            case "PROVIDER_FATAL":
+                return ErrorCode.PROVIDER_FATAL;
+            case "GENERAL":
+                return ErrorCode.GENERAL;
+            default:
+                throw new IllegalArgumentException("Unknown error code in fixture: " + code);
         }
     }
 
-    // ---- Fixture model classes ----
-
-    @JsonIgnoreProperties(ignoreUnknown = true)
     static class Fixture {
         @JsonDeserialize(using = RawJsonDeserializer.class)
         public String response;
         public FixtureCase[] cases;
     }
 
-    @JsonIgnoreProperties(ignoreUnknown = true)
     static class FixtureCase {
         public String description;
         public FixtureConfiguration configuration;
         public FixtureExpected expected;
     }
 
-    @JsonIgnoreProperties(ignoreUnknown = true)
     static class FixtureConfiguration {
         public String slug;
         public boolean defaultValue;
         public Map<String, String> context;
     }
 
-    @JsonIgnoreProperties(ignoreUnknown = true)
     static class FixtureExpected {
         public boolean value;
         public String errorCode;
     }
 
     static class RawJsonDeserializer extends JsonDeserializer<String> {
         @Override
-        public String deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
+        public String deserialize(JsonParser jp, DeserializationContext dc) throws IOException {
             long begin = jp.currentLocation().getCharOffset();
             jp.skipChildren();
             long end = jp.currentLocation().getCharOffset();