From 29a92681610d21ac34a1f90b6abc2c2d84205213 Mon Sep 17 00:00:00 2001 From: Lucas Barros Date: Tue, 10 Nov 2026 00:04:38 -0300 Subject: [PATCH] fix(jsonlogic): report missing rules and type mismatches as errors A missing rule returned the default with reason ERROR but no error code, so the SDK treated the evaluation as successful and error hooks did not run. A rule whose result had another type than requested was cast unchecked: a boolean evaluation could hand a String to the caller, and an integer evaluation of a non-number failed with a ClassCastException. Return FLAG_NOT_FOUND for a missing rule and TYPE_MISMATCH with the default value when the result type does not match. Signed-off-by: Lucas Barros --- .../jsonlogic/JsonlogicProvider.java | 45 ++++++++----- .../jsonlogic/JsonlogicProviderTest.java | 64 +++++++++++++++++++ 2 files changed, 92 insertions(+), 17 deletions(-) diff --git a/providers/jsonlogic-eval-provider/src/main/java/dev/openfeature/contrib/providers/jsonlogic/JsonlogicProvider.java b/providers/jsonlogic-eval-provider/src/main/java/dev/openfeature/contrib/providers/jsonlogic/JsonlogicProvider.java index 2129edbb9f..98891f3542 100644 --- a/providers/jsonlogic-eval-provider/src/main/java/dev/openfeature/contrib/providers/jsonlogic/JsonlogicProvider.java +++ b/providers/jsonlogic-eval-provider/src/main/java/dev/openfeature/contrib/providers/jsonlogic/JsonlogicProvider.java @@ -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; @@ -37,23 +38,23 @@ public Metadata getMetadata() { @Override public ProviderEvaluation 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 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 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 getDoubleEvaluation(String key, Double defaultValue, EvaluationContext ctx) { - return evalRuleForKey(key, defaultValue, ctx); + return evalRuleForKey(key, defaultValue, ctx, Number.class, (o) -> ((Number) o).doubleValue()); } @Override @@ -62,27 +63,37 @@ public ProviderEvaluation getObjectEvaluation(String s, Value value, Eval throw new UnsupportedOperationException("Haven't gotten there yet."); } - private ProviderEvaluation evalRuleForKey(String key, T defaultValue, EvaluationContext ctx) { - return evalRuleForKey(key, defaultValue, ctx, (o) -> (T) o); - } - private ProviderEvaluation evalRuleForKey( - String key, T defaultValue, EvaluationContext ctx, Function resultToType) { + String key, T defaultValue, EvaluationContext ctx, Class resultType, Function resultToType) { String rule = fetcher.getRuleForKey(key); if (rule == null) { - return ProviderEvaluation.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.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.builder().value(resultToType.apply(result)).build(); + } + + private static ProviderEvaluation error(T defaultValue, ErrorCode errorCode, String errorMessage) { + return ProviderEvaluation.builder() + .value(defaultValue) + .reason(Reason.ERROR.toString()) + .errorCode(errorCode) + .errorMessage(errorMessage) + .build(); } } diff --git a/providers/jsonlogic-eval-provider/src/test/java/dev/openfeature/contrib/providers/jsonlogic/JsonlogicProviderTest.java b/providers/jsonlogic-eval-provider/src/test/java/dev/openfeature/contrib/providers/jsonlogic/JsonlogicProviderTest.java index 3cfcf56c07..dc9880f321 100644 --- a/providers/jsonlogic-eval-provider/src/test/java/dev/openfeature/contrib/providers/jsonlogic/JsonlogicProviderTest.java +++ b/providers/jsonlogic-eval-provider/src/test/java/dev/openfeature/contrib/providers/jsonlogic/JsonlogicProviderTest.java @@ -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 { @@ -57,6 +65,62 @@ public void missingKey() throws Exception { ProviderEvaluation 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() { + @Override + public void error(HookContext ctx, Exception error, Map hints) { + errorHookCalled.set(true); + } + }); + + FlagEvaluationDetails 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 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 asInteger = iep.getIntegerEvaluation("many-types", 7, stringCtx); + assertEquals(7, asInteger.getValue()); + assertEquals(ErrorCode.TYPE_MISMATCH, asInteger.getErrorCode()); + + ProviderEvaluation asString = iep.getStringEvaluation("many-types", "default", new ImmutableContext()); + assertEquals("default", asString.getValue()); + assertEquals(ErrorCode.TYPE_MISMATCH, asString.getErrorCode()); } @Test