diff --git a/providers/ofrep/src/main/java/dev/openfeature/contrib/providers/ofrep/internal/Resolver.java b/providers/ofrep/src/main/java/dev/openfeature/contrib/providers/ofrep/internal/Resolver.java index 31f282e269..921fd4ab1c 100644 --- a/providers/ofrep/src/main/java/dev/openfeature/contrib/providers/ofrep/internal/Resolver.java +++ b/providers/ofrep/src/main/java/dev/openfeature/contrib/providers/ofrep/internal/Resolver.java @@ -169,7 +169,7 @@ private ImmutableMetadata convertToImmutableMetadata(Map metadat private ProviderEvaluation handleResolved( String key, T defaultValue, Class type, OfrepResponse response, ImmutableMetadata metadata) { - Object responseValue = response.getValue(); + Object responseValue = convertNumberIfLossless(type, response.getValue()); if (responseValue == null) { return ProviderEvaluation.builder() @@ -198,6 +198,41 @@ private ProviderEvaluation handleResolved( .build(); } + /** + * Converts a JSON number to the requested numeric type when no information is lost: an integer is + * widened to a double, and an integral double (e.g. {@code 10.0}) within the int range is narrowed + * to an integer. JSON doesn't keep the distinction, so a server can send {@code 10} for a float flag + * or {@code 10.0} for an integer one. Anything else is returned unchanged and fails the type check. + */ + static Object convertNumberIfLossless(Class type, Object value) { + if (!(value instanceof Number) || type.isInstance(value)) { + return value; + } + Number number = (Number) value; + if (type == Double.class && (value instanceof Integer || value instanceof Long)) { + long longValue = number.longValue(); + double doubleValue = (double) longValue; + if (longValue != Long.MAX_VALUE && (long) doubleValue == longValue) { + return doubleValue; + } + } else if (type == Integer.class) { + if (value instanceof Long) { + long longValue = number.longValue(); + if (longValue >= Integer.MIN_VALUE && longValue <= Integer.MAX_VALUE) { + return (int) longValue; + } + } else if (value instanceof Double || value instanceof Float) { + double doubleValue = number.doubleValue(); + if (doubleValue == Math.rint(doubleValue) + && doubleValue >= Integer.MIN_VALUE + && doubleValue <= Integer.MAX_VALUE) { + return (int) doubleValue; + } + } + } + return value; + } + private ProviderEvaluation handleFlagNotFound(String key, T defaultValue, ImmutableMetadata metadata) { return ProviderEvaluation.builder() .value(defaultValue) diff --git a/providers/ofrep/src/test/java/dev/openfeature/contrib/OfrepProviderTest.java b/providers/ofrep/src/test/java/dev/openfeature/contrib/OfrepProviderTest.java index 80882161e8..b056065538 100644 --- a/providers/ofrep/src/test/java/dev/openfeature/contrib/OfrepProviderTest.java +++ b/providers/ofrep/src/test/java/dev/openfeature/contrib/OfrepProviderTest.java @@ -270,6 +270,45 @@ void testSuccessfulDoubleResponse() throws JsonProcessingException { assertTrue(FLAG_IMMUTABLE_METADATA.equals(evaluation.getFlagMetadata())); } + @Test + void testIntegerValueResolvedAsDouble() { + mockWebServer.enqueue(new MockResponse() + .setBody("{\"key\":\"" + FLAG_KEY + "\",\"value\":10,\"reason\":\"STATIC\",\"metadata\":{}}") + .setResponseCode(200)); + + ProviderEvaluation evaluation = + ofrepProvider.getDoubleEvaluation(FLAG_KEY, DEFAULT_DOUBLE_VALUE, new ImmutableContext()); + + assertEquals(10.0, evaluation.getValue()); + assertNull(evaluation.getErrorCode()); + } + + @Test + void testIntegralDoubleValueResolvedAsInteger() { + mockWebServer.enqueue(new MockResponse() + .setBody("{\"key\":\"" + FLAG_KEY + "\",\"value\":10.0,\"reason\":\"STATIC\",\"metadata\":{}}") + .setResponseCode(200)); + + ProviderEvaluation evaluation = + ofrepProvider.getIntegerEvaluation(FLAG_KEY, DEFAULT_INT_VALUE, new ImmutableContext()); + + assertEquals(10, evaluation.getValue()); + assertNull(evaluation.getErrorCode()); + } + + @Test + void testFractionalDoubleValueIsNotNarrowedToInteger() { + mockWebServer.enqueue(new MockResponse() + .setBody("{\"key\":\"" + FLAG_KEY + "\",\"value\":0.5,\"reason\":\"STATIC\",\"metadata\":{}}") + .setResponseCode(200)); + + ProviderEvaluation evaluation = + ofrepProvider.getIntegerEvaluation(FLAG_KEY, DEFAULT_INT_VALUE, new ImmutableContext()); + + assertEquals(DEFAULT_INT_VALUE, evaluation.getValue()); + assertEquals(ErrorCode.TYPE_MISMATCH, evaluation.getErrorCode()); + } + @Test void testSuccessfulObjectResponse() throws JsonProcessingException { OfrepResponse successfulObjectResponse = new OfrepResponse(); diff --git a/providers/ofrep/src/test/java/dev/openfeature/contrib/providers/ofrep/internal/ResolverLosslessNumberConversionTest.java b/providers/ofrep/src/test/java/dev/openfeature/contrib/providers/ofrep/internal/ResolverLosslessNumberConversionTest.java new file mode 100644 index 0000000000..6a9e83d4b2 --- /dev/null +++ b/providers/ofrep/src/test/java/dev/openfeature/contrib/providers/ofrep/internal/ResolverLosslessNumberConversionTest.java @@ -0,0 +1,43 @@ +package dev.openfeature.contrib.providers.ofrep.internal; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import org.junit.jupiter.api.Test; + +class ResolverLosslessNumberConversionTest { + + @Test + void widensIntegersToDouble() { + assertEquals(10.0, Resolver.convertNumberIfLossless(Double.class, 10)); + assertEquals(4_000_000_000.0, Resolver.convertNumberIfLossless(Double.class, 4_000_000_000L)); + } + + @Test + void keepsLongsThatDoubleCannotRepresent() { + long notExact = (1L << 53) + 1; + assertEquals(notExact, Resolver.convertNumberIfLossless(Double.class, notExact)); + assertEquals(Long.MAX_VALUE, Resolver.convertNumberIfLossless(Double.class, Long.MAX_VALUE)); + } + + @Test + void narrowsIntegralNumbersToInteger() { + assertEquals(10, Resolver.convertNumberIfLossless(Integer.class, 10.0)); + assertEquals(-3, Resolver.convertNumberIfLossless(Integer.class, -3.0)); + assertEquals(7, Resolver.convertNumberIfLossless(Integer.class, 7L)); + } + + @Test + void keepsValuesThatWouldLoseInformation() { + assertEquals(0.5, Resolver.convertNumberIfLossless(Integer.class, 0.5)); + assertEquals(3e10, Resolver.convertNumberIfLossless(Integer.class, 3e10)); + assertEquals(5_000_000_000L, Resolver.convertNumberIfLossless(Integer.class, 5_000_000_000L)); + } + + @Test + void leavesOtherTypesAlone() { + assertEquals(1.5, Resolver.convertNumberIfLossless(Double.class, 1.5)); + assertEquals("10", Resolver.convertNumberIfLossless(Integer.class, "10")); + assertEquals(10, Resolver.convertNumberIfLossless(String.class, 10)); + assertEquals(10, Resolver.convertNumberIfLossless(Boolean.class, 10)); + } +}