Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -169,7 +169,7 @@ private ImmutableMetadata convertToImmutableMetadata(Map<String, Object> metadat
private <T> ProviderEvaluation<T> handleResolved(
String key, T defaultValue, Class<T> type, OfrepResponse response, ImmutableMetadata metadata) {

Object responseValue = response.getValue();
Object responseValue = convertNumberIfLossless(type, response.getValue());

if (responseValue == null) {
return ProviderEvaluation.<T>builder()
Expand Down Expand Up @@ -198,6 +198,41 @@ private <T> ProviderEvaluation<T> handleResolved(
.build();
}

/**
* Converts a JSON number to the requested numeric type when no information is lost: an integer is
Comment thread
lbarrosby marked this conversation as resolved.
Resolved
* 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;
Comment thread
lbarrosby marked this conversation as resolved.
Resolved
}
} 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 <T> ProviderEvaluation<T> handleFlagNotFound(String key, T defaultValue, ImmutableMetadata metadata) {
return ProviderEvaluation.<T>builder()
.value(defaultValue)
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -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<Double> 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<Integer> 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<Integer> 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();
Expand Down
Original file line number Diff line number Diff line change
@@ -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));
}
}
Loading