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
@@ -1,5 +1,6 @@
package dev.openfeature.contrib.providers.jsonlogic;

import dev.openfeature.sdk.ErrorCode;
import dev.openfeature.sdk.EvaluationContext;
import dev.openfeature.sdk.FeatureProvider;
import dev.openfeature.sdk.Metadata;
Expand Down Expand Up @@ -37,23 +38,23 @@ public Metadata getMetadata() {

@Override
public ProviderEvaluation<Boolean> getBooleanEvaluation(String key, Boolean defaultValue, EvaluationContext ctx) {
return evalRuleForKey(key, defaultValue, ctx);
return evalRuleForKey(key, defaultValue, ctx, Boolean.class, Boolean.class::cast);
}

@Override
public ProviderEvaluation<String> getStringEvaluation(String key, String defaultValue, EvaluationContext ctx) {
return evalRuleForKey(key, defaultValue, ctx);
return evalRuleForKey(key, defaultValue, ctx, String.class, String.class::cast);
}

@Override
public ProviderEvaluation<Integer> getIntegerEvaluation(String key, Integer defaultValue, EvaluationContext ctx) {
// jsonlogic only returns doubles, not integers.
return evalRuleForKey(key, defaultValue, ctx, (o) -> ((Double) o).intValue());
return evalRuleForKey(key, defaultValue, ctx, Number.class, (o) -> ((Number) o).intValue());
}

@Override
public ProviderEvaluation<Double> getDoubleEvaluation(String key, Double defaultValue, EvaluationContext ctx) {
return evalRuleForKey(key, defaultValue, ctx);
return evalRuleForKey(key, defaultValue, ctx, Number.class, (o) -> ((Number) o).doubleValue());
}

@Override
Expand All @@ -62,27 +63,37 @@ public ProviderEvaluation<Value> getObjectEvaluation(String s, Value value, Eval
throw new UnsupportedOperationException("Haven't gotten there yet.");
}

private <T> ProviderEvaluation<T> evalRuleForKey(String key, T defaultValue, EvaluationContext ctx) {
return evalRuleForKey(key, defaultValue, ctx, (o) -> (T) o);
}

private <T> ProviderEvaluation<T> evalRuleForKey(
String key, T defaultValue, EvaluationContext ctx, Function<Object, T> resultToType) {
String key, T defaultValue, EvaluationContext ctx, Class<?> resultType, Function<Object, T> resultToType) {
String rule = fetcher.getRuleForKey(key);
if (rule == null) {
return ProviderEvaluation.<T>builder()
.value(defaultValue)
.reason(Reason.ERROR.toString())
.errorMessage("Unable to find rules for the given key")
.build();
return error(defaultValue, ErrorCode.FLAG_NOT_FOUND, "Unable to find rules for the given key");
}

Object result;
try {
return ProviderEvaluation.<T>builder()
.value(resultToType.apply(this.logic.apply(rule, ctx.asObjectMap())))
.build();
result = this.logic.apply(rule, ctx.asObjectMap());
} catch (JsonLogicException e) {
throw new ParseError(e);
}

if (!resultType.isInstance(result)) {
String actual = result == null ? "null" : result.getClass().getSimpleName();
return error(
defaultValue,
ErrorCode.TYPE_MISMATCH,
"Rule for key " + key + " returned " + actual + ", expected " + resultType.getSimpleName());
}

return ProviderEvaluation.<T>builder().value(resultToType.apply(result)).build();
}

private static <T> ProviderEvaluation<T> error(T defaultValue, ErrorCode errorCode, String errorMessage) {
return ProviderEvaluation.<T>builder()
.value(defaultValue)
.reason(Reason.ERROR.toString())
.errorCode(errorCode)
.errorMessage(errorMessage)
.build();
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -4,13 +4,21 @@
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.*;

import dev.openfeature.sdk.Client;
import dev.openfeature.sdk.ErrorCode;
import dev.openfeature.sdk.FlagEvaluationDetails;
import dev.openfeature.sdk.Hook;
import dev.openfeature.sdk.HookContext;
import dev.openfeature.sdk.ImmutableContext;
import dev.openfeature.sdk.OpenFeatureAPI;
import dev.openfeature.sdk.ProviderEvaluation;
import dev.openfeature.sdk.Value;
import io.github.jamsesso.jsonlogic.JsonLogic;
import java.net.URL;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import org.junit.jupiter.api.Test;

class JsonlogicProviderTest {
Expand Down Expand Up @@ -57,6 +65,62 @@ public void missingKey() throws Exception {
ProviderEvaluation<Boolean> result = iep.getBooleanEvaluation("missingKey", false, null);
assertEquals("Unable to find rules for the given key", result.getErrorMessage());
assertEquals("ERROR", result.getReason());
assertEquals(ErrorCode.FLAG_NOT_FOUND, result.getErrorCode());
assertEquals(false, result.getValue());
}

@Test
public void missingKeyThroughClientRunsErrorHooks() throws Exception {
URL v = this.getClass().getResource("/test-rules.json");
OpenFeatureAPI api = OpenFeatureAPI.getInstance();
api.setProviderAndWait("jsonlogic-missing-key", new JsonlogicProvider(new FileBasedFetcher(v.toURI())));
AtomicBoolean errorHookCalled = new AtomicBoolean();
Client client = api.getClient("jsonlogic-missing-key");
client.addHooks(new Hook<Boolean>() {
@Override
public void error(HookContext<Boolean> ctx, Exception error, Map<String, Object> hints) {
errorHookCalled.set(true);
}
});

FlagEvaluationDetails<Boolean> details = client.getBooleanDetails("missingKey", true);

assertEquals(true, details.getValue());
assertEquals(ErrorCode.FLAG_NOT_FOUND, details.getErrorCode());
assertTrue(errorHookCalled.get());
}

@Test
public void numberRules() throws Exception {
URL v = this.getClass().getResource("/test-rules.json");
JsonlogicProvider iep = new JsonlogicProvider(new FileBasedFetcher(v.toURI()));
ImmutableContext doubleCtx = new ImmutableContext(Collections.singletonMap("double", new Value(true)));

assertEquals(
2,
iep.getIntegerEvaluation("many-types", 0, new ImmutableContext())
.getValue());
assertEquals(4.2D, iep.getDoubleEvaluation("many-types", 0D, doubleCtx).getValue());
}

@Test
public void typeMismatch() throws Exception {
URL v = this.getClass().getResource("/test-rules.json");
JsonlogicProvider iep = new JsonlogicProvider(new FileBasedFetcher(v.toURI()));
ImmutableContext stringCtx = new ImmutableContext(Collections.singletonMap("string", new Value(true)));

ProviderEvaluation<Boolean> asBoolean = iep.getBooleanEvaluation("many-types", false, stringCtx);
assertEquals(false, asBoolean.getValue());
assertEquals(ErrorCode.TYPE_MISMATCH, asBoolean.getErrorCode());
assertEquals("Rule for key many-types returned String, expected Boolean", asBoolean.getErrorMessage());

ProviderEvaluation<Integer> asInteger = iep.getIntegerEvaluation("many-types", 7, stringCtx);
assertEquals(7, asInteger.getValue());
assertEquals(ErrorCode.TYPE_MISMATCH, asInteger.getErrorCode());

ProviderEvaluation<String> asString = iep.getStringEvaluation("many-types", "default", new ImmutableContext());
assertEquals("default", asString.getValue());
assertEquals(ErrorCode.TYPE_MISMATCH, asString.getErrorCode());
}

@Test
Expand Down
Loading