From 6c84d9d71b6655f69cfb257513239e71c30da29b Mon Sep 17 00:00:00 2001 From: Lucas Barros Date: Sun, 8 Nov 2026 00:51:52 -0300 Subject: [PATCH 1/2] fix(ofrep): coerce numbers between integer and double when lossless JSON doesn't keep the integer/float distinction: a flagd OFREP server sends 10 for a float flag set to 10.0, and Jackson reads it as an Integer, so getDoubleValue returned the default with TYPE_MISMATCH. Widen integers to double, and narrow integral doubles in the int range to integer. A fractional value requested as an integer is still a TYPE_MISMATCH. Signed-off-by: Lucas Barros --- .../providers/ofrep/internal/Resolver.java | 37 +++++++++++++++- .../contrib/OfrepProviderTest.java | 39 +++++++++++++++++ .../internal/ResolverNumericCoercionTest.java | 42 +++++++++++++++++++ 3 files changed, 117 insertions(+), 1 deletion(-) create mode 100644 providers/ofrep/src/test/java/dev/openfeature/contrib/providers/ofrep/internal/ResolverNumericCoercionTest.java 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..518a447113 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 = coerceNumber(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 coerceNumber(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 ((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/ResolverNumericCoercionTest.java b/providers/ofrep/src/test/java/dev/openfeature/contrib/providers/ofrep/internal/ResolverNumericCoercionTest.java new file mode 100644 index 0000000000..be48124712 --- /dev/null +++ b/providers/ofrep/src/test/java/dev/openfeature/contrib/providers/ofrep/internal/ResolverNumericCoercionTest.java @@ -0,0 +1,42 @@ +package dev.openfeature.contrib.providers.ofrep.internal; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import org.junit.jupiter.api.Test; + +class ResolverNumericCoercionTest { + + @Test + void widensIntegersToDouble() { + assertEquals(10.0, Resolver.coerceNumber(Double.class, 10)); + assertEquals(4_000_000_000.0, Resolver.coerceNumber(Double.class, 4_000_000_000L)); + } + + @Test + void keepsLongsThatDoubleCannotRepresent() { + long notExact = (1L << 53) + 1; + assertEquals(notExact, Resolver.coerceNumber(Double.class, notExact)); + } + + @Test + void narrowsIntegralNumbersToInteger() { + assertEquals(10, Resolver.coerceNumber(Integer.class, 10.0)); + assertEquals(-3, Resolver.coerceNumber(Integer.class, -3.0)); + assertEquals(7, Resolver.coerceNumber(Integer.class, 7L)); + } + + @Test + void keepsValuesThatWouldLoseInformation() { + assertEquals(0.5, Resolver.coerceNumber(Integer.class, 0.5)); + assertEquals(3e10, Resolver.coerceNumber(Integer.class, 3e10)); + assertEquals(5_000_000_000L, Resolver.coerceNumber(Integer.class, 5_000_000_000L)); + } + + @Test + void leavesOtherTypesAlone() { + assertEquals(1.5, Resolver.coerceNumber(Double.class, 1.5)); + assertEquals("10", Resolver.coerceNumber(Integer.class, "10")); + assertEquals(10, Resolver.coerceNumber(String.class, 10)); + assertEquals(10, Resolver.coerceNumber(Boolean.class, 10)); + } +} From 868be5f6d3b1705365d1a94c18d1c35c327a03f3 Mon Sep 17 00:00:00 2001 From: Lucas Barros Date: Mon, 9 Nov 2026 18:50:00 -0300 Subject: [PATCH 2/2] refactor(ofrep): rename coerceNumber to convertNumberIfLossless Also keep Long.MAX_VALUE as is for double flags: it rounds up when widened and the cast back saturates, so the round-trip check let it through. Signed-off-by: Lucas Barros --- .../providers/ofrep/internal/Resolver.java | 6 +-- .../ResolverLosslessNumberConversionTest.java | 43 +++++++++++++++++++ .../internal/ResolverNumericCoercionTest.java | 42 ------------------ 3 files changed, 46 insertions(+), 45 deletions(-) create mode 100644 providers/ofrep/src/test/java/dev/openfeature/contrib/providers/ofrep/internal/ResolverLosslessNumberConversionTest.java delete mode 100644 providers/ofrep/src/test/java/dev/openfeature/contrib/providers/ofrep/internal/ResolverNumericCoercionTest.java 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 518a447113..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 = coerceNumber(type, response.getValue()); + Object responseValue = convertNumberIfLossless(type, response.getValue()); if (responseValue == null) { return ProviderEvaluation.builder() @@ -204,7 +204,7 @@ private ProviderEvaluation handleResolved( * 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 coerceNumber(Class type, Object value) { + static Object convertNumberIfLossless(Class type, Object value) { if (!(value instanceof Number) || type.isInstance(value)) { return value; } @@ -212,7 +212,7 @@ static Object coerceNumber(Class type, Object value) { if (type == Double.class && (value instanceof Integer || value instanceof Long)) { long longValue = number.longValue(); double doubleValue = (double) longValue; - if ((long) doubleValue == longValue) { + if (longValue != Long.MAX_VALUE && (long) doubleValue == longValue) { return doubleValue; } } else if (type == Integer.class) { 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)); + } +} diff --git a/providers/ofrep/src/test/java/dev/openfeature/contrib/providers/ofrep/internal/ResolverNumericCoercionTest.java b/providers/ofrep/src/test/java/dev/openfeature/contrib/providers/ofrep/internal/ResolverNumericCoercionTest.java deleted file mode 100644 index be48124712..0000000000 --- a/providers/ofrep/src/test/java/dev/openfeature/contrib/providers/ofrep/internal/ResolverNumericCoercionTest.java +++ /dev/null @@ -1,42 +0,0 @@ -package dev.openfeature.contrib.providers.ofrep.internal; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -import org.junit.jupiter.api.Test; - -class ResolverNumericCoercionTest { - - @Test - void widensIntegersToDouble() { - assertEquals(10.0, Resolver.coerceNumber(Double.class, 10)); - assertEquals(4_000_000_000.0, Resolver.coerceNumber(Double.class, 4_000_000_000L)); - } - - @Test - void keepsLongsThatDoubleCannotRepresent() { - long notExact = (1L << 53) + 1; - assertEquals(notExact, Resolver.coerceNumber(Double.class, notExact)); - } - - @Test - void narrowsIntegralNumbersToInteger() { - assertEquals(10, Resolver.coerceNumber(Integer.class, 10.0)); - assertEquals(-3, Resolver.coerceNumber(Integer.class, -3.0)); - assertEquals(7, Resolver.coerceNumber(Integer.class, 7L)); - } - - @Test - void keepsValuesThatWouldLoseInformation() { - assertEquals(0.5, Resolver.coerceNumber(Integer.class, 0.5)); - assertEquals(3e10, Resolver.coerceNumber(Integer.class, 3e10)); - assertEquals(5_000_000_000L, Resolver.coerceNumber(Integer.class, 5_000_000_000L)); - } - - @Test - void leavesOtherTypesAlone() { - assertEquals(1.5, Resolver.coerceNumber(Double.class, 1.5)); - assertEquals("10", Resolver.coerceNumber(Integer.class, "10")); - assertEquals(10, Resolver.coerceNumber(String.class, 10)); - assertEquals(10, Resolver.coerceNumber(Boolean.class, 10)); - } -}