decision_agent 0.3.0 → 1.0.1

data/spec/json_rule_evaluator_spec.rb

@@ -1,587 +0,0 @@
-require "spec_helper"
-
-RSpec.describe DecisionAgent::Evaluators::JsonRuleEvaluator do
-  describe "basic rule matching" do
-    it "matches simple equality rule" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "status", op: "eq", value: "active" },
-            then: { decision: "approve", weight: 0.8, reason: "Status is active" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      context = DecisionAgent::Context.new({ status: "active" })
-
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation).not_to be_nil
-      expect(evaluation.decision).to eq("approve")
-      expect(evaluation.weight).to eq(0.8)
-      expect(evaluation.reason).to eq("Status is active")
-      expect(evaluation.metadata[:rule_id]).to eq("rule_1")
-    end
-
-    it "returns nil when no rules match" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "status", op: "eq", value: "active" },
-            then: { decision: "approve" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      context = DecisionAgent::Context.new({ status: "inactive" })
-
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation).to be_nil
-    end
-
-    it "matches first rule when multiple rules match" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "priority", op: "eq", value: "high" },
-            then: { decision: "escalate" }
-          },
-          {
-            id: "rule_2",
-            if: { field: "priority", op: "eq", value: "high" },
-            then: { decision: "notify" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      context = DecisionAgent::Context.new({ priority: "high" })
-
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation.decision).to eq("escalate")
-      expect(evaluation.metadata[:rule_id]).to eq("rule_1")
-    end
-  end
-
-  describe "all/any conditions" do
-    it "matches 'all' condition when all sub-conditions are true" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: {
-              all: [
-                { field: "priority", op: "eq", value: "high" },
-                { field: "hours", op: "gte", value: 4 }
-              ]
-            },
-            then: { decision: "notify" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      context = DecisionAgent::Context.new({ priority: "high", hours: 5 })
-
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation).not_to be_nil
-      expect(evaluation.decision).to eq("notify")
-    end
-
-    it "does not match 'all' when one sub-condition fails" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: {
-              all: [
-                { field: "priority", op: "eq", value: "high" },
-                { field: "hours", op: "gte", value: 4 }
-              ]
-            },
-            then: { decision: "notify" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      context = DecisionAgent::Context.new({ priority: "high", hours: 2 })
-
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation).to be_nil
-    end
-
-    it "matches 'any' condition when at least one sub-condition is true" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: {
-              any: [
-                { field: "priority", op: "eq", value: "critical" },
-                { field: "hours", op: "gte", value: 24 }
-              ]
-            },
-            then: { decision: "escalate" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      context = DecisionAgent::Context.new({ priority: "low", hours: 30 })
-
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation).not_to be_nil
-      expect(evaluation.decision).to eq("escalate")
-    end
-
-    it "does not match 'any' when all sub-conditions fail" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: {
-              any: [
-                { field: "priority", op: "eq", value: "critical" },
-                { field: "hours", op: "gte", value: 24 }
-              ]
-            },
-            then: { decision: "escalate" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      context = DecisionAgent::Context.new({ priority: "low", hours: 5 })
-
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation).to be_nil
-    end
-  end
-
-  describe "comparison operators" do
-    it "supports gt (greater than)" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "score", op: "gt", value: 80 },
-            then: { decision: "pass" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-
-      context1 = DecisionAgent::Context.new({ score: 85 })
-      context2 = DecisionAgent::Context.new({ score: 80 })
-
-      expect(evaluator.evaluate(context1)).not_to be_nil
-      expect(evaluator.evaluate(context2)).to be_nil
-    end
-
-    it "supports gte (greater than or equal)" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "score", op: "gte", value: 80 },
-            then: { decision: "pass" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-
-      context1 = DecisionAgent::Context.new({ score: 80 })
-      context2 = DecisionAgent::Context.new({ score: 79 })
-
-      expect(evaluator.evaluate(context1)).not_to be_nil
-      expect(evaluator.evaluate(context2)).to be_nil
-    end
-
-    it "supports lt (less than)" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "temperature", op: "lt", value: 32 },
-            then: { decision: "freeze" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-
-      context1 = DecisionAgent::Context.new({ temperature: 30 })
-      context2 = DecisionAgent::Context.new({ temperature: 32 })
-
-      expect(evaluator.evaluate(context1)).not_to be_nil
-      expect(evaluator.evaluate(context2)).to be_nil
-    end
-
-    it "supports lte (less than or equal)" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "temperature", op: "lte", value: 32 },
-            then: { decision: "freeze" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-
-      context1 = DecisionAgent::Context.new({ temperature: 32 })
-      context2 = DecisionAgent::Context.new({ temperature: 33 })
-
-      expect(evaluator.evaluate(context1)).not_to be_nil
-      expect(evaluator.evaluate(context2)).to be_nil
-    end
-
-    it "supports neq (not equal)" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "status", op: "neq", value: "closed" },
-            then: { decision: "process" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-
-      context1 = DecisionAgent::Context.new({ status: "open" })
-      context2 = DecisionAgent::Context.new({ status: "closed" })
-
-      expect(evaluator.evaluate(context1)).not_to be_nil
-      expect(evaluator.evaluate(context2)).to be_nil
-    end
-
-    it "supports in (array membership)" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "status", op: "in", value: %w[open pending review] },
-            then: { decision: "active" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-
-      context1 = DecisionAgent::Context.new({ status: "pending" })
-      context2 = DecisionAgent::Context.new({ status: "closed" })
-
-      expect(evaluator.evaluate(context1)).not_to be_nil
-      expect(evaluator.evaluate(context2)).to be_nil
-    end
-
-    it "supports present (field exists and not empty)" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "assignee", op: "present" },
-            then: { decision: "assigned" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-
-      context1 = DecisionAgent::Context.new({ assignee: "alice" })
-      context2 = DecisionAgent::Context.new({ assignee: nil })
-      context3 = DecisionAgent::Context.new({ assignee: "" })
-      context4 = DecisionAgent::Context.new({})
-
-      expect(evaluator.evaluate(context1)).not_to be_nil
-      expect(evaluator.evaluate(context2)).to be_nil
-      expect(evaluator.evaluate(context3)).to be_nil
-      expect(evaluator.evaluate(context4)).to be_nil
-    end
-
-    it "supports blank (field missing, nil, or empty)" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "description", op: "blank" },
-            then: { decision: "needs_description" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-
-      context1 = DecisionAgent::Context.new({ description: "" })
-      context2 = DecisionAgent::Context.new({ description: nil })
-      context3 = DecisionAgent::Context.new({})
-      context4 = DecisionAgent::Context.new({ description: "valid" })
-
-      expect(evaluator.evaluate(context1)).not_to be_nil
-      expect(evaluator.evaluate(context2)).not_to be_nil
-      expect(evaluator.evaluate(context3)).not_to be_nil
-      expect(evaluator.evaluate(context4)).to be_nil
-    end
-  end
-
-  describe "nested field access" do
-    it "supports dot notation for nested fields" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "user.role", op: "eq", value: "admin" },
-            then: { decision: "allow" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-
-      context1 = DecisionAgent::Context.new({ user: { role: "admin" } })
-      context2 = DecisionAgent::Context.new({ user: { role: "user" } })
-
-      expect(evaluator.evaluate(context1)).not_to be_nil
-      expect(evaluator.evaluate(context2)).to be_nil
-    end
-
-    it "handles missing nested fields gracefully" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "user.role", op: "eq", value: "admin" },
-            then: { decision: "allow" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-
-      context1 = DecisionAgent::Context.new({})
-      context2 = DecisionAgent::Context.new({ user: nil })
-
-      expect(evaluator.evaluate(context1)).to be_nil
-      expect(evaluator.evaluate(context2)).to be_nil
-    end
-  end
-
-  describe "invalid DSL handling" do
-    it "raises InvalidRuleDslError for malformed JSON" do
-      expect do
-        DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: "{ invalid json")
-      end.to raise_error(DecisionAgent::InvalidRuleDslError, /Invalid JSON/)
-    end
-
-    it "raises InvalidRuleDslError when version is missing" do
-      rules = { rules: [] }
-
-      expect do
-        DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      end.to raise_error(DecisionAgent::InvalidRuleDslError, /version/)
-    end
-
-    it "raises InvalidRuleDslError when rules array is missing" do
-      rules = { version: "1.0" }
-
-      expect do
-        DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      end.to raise_error(DecisionAgent::InvalidRuleDslError, /rules/)
-    end
-
-    it "raises InvalidRuleDslError when rule is missing id" do
-      rules = {
-        version: "1.0",
-        rules: [
-          {
-            if: { field: "status", op: "eq", value: "active" },
-            then: { decision: "approve" }
-          }
-        ]
-      }
-
-      expect do
-        DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      end.to raise_error(DecisionAgent::InvalidRuleDslError, /Missing required field 'id'/)
-    end
-
-    it "raises InvalidRuleDslError when rule is missing if clause" do
-      rules = {
-        version: "1.0",
-        rules: [
-          {
-            id: "rule_1",
-            then: { decision: "approve" }
-          }
-        ]
-      }
-
-      expect do
-        DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      end.to raise_error(DecisionAgent::InvalidRuleDslError, /Missing required field 'if'/)
-    end
-
-    it "raises InvalidRuleDslError when rule is missing then clause" do
-      rules = {
-        version: "1.0",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "status", op: "eq", value: "active" }
-          }
-        ]
-      }
-
-      expect do
-        DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      end.to raise_error(DecisionAgent::InvalidRuleDslError, /Missing required field 'then'/)
-    end
-
-    it "raises InvalidRuleDslError when then clause is missing decision" do
-      rules = {
-        version: "1.0",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "status", op: "eq", value: "active" },
-            then: { weight: 0.8 }
-          }
-        ]
-      }
-
-      expect do
-        DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      end.to raise_error(DecisionAgent::InvalidRuleDslError, /Missing required field 'decision'/)
-    end
-  end
-
-  describe "default values" do
-    it "uses default weight of 1.0 when not specified" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "status", op: "eq", value: "active" },
-            then: { decision: "approve" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      context = DecisionAgent::Context.new({ status: "active" })
-
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation.weight).to eq(1.0)
-    end
-
-    it "uses default reason when not specified" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "status", op: "eq", value: "active" },
-            then: { decision: "approve" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      context = DecisionAgent::Context.new({ status: "active" })
-
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation.reason).to eq("Rule matched")
-    end
-  end
-
-  describe "complex nested conditions" do
-    it "handles nested all/any combinations" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: {
-              all: [
-                { field: "priority", op: "eq", value: "high" },
-                {
-                  any: [
-                    { field: "hours", op: "gte", value: 24 },
-                    { field: "escalated", op: "eq", value: true }
-                  ]
-                }
-              ]
-            },
-            then: { decision: "urgent" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-
-      context1 = DecisionAgent::Context.new({ priority: "high", hours: 30, escalated: false })
-      context2 = DecisionAgent::Context.new({ priority: "high", hours: 5, escalated: true })
-      context3 = DecisionAgent::Context.new({ priority: "low", hours: 30, escalated: true })
-
-      expect(evaluator.evaluate(context1)).not_to be_nil
-      expect(evaluator.evaluate(context2)).not_to be_nil
-      expect(evaluator.evaluate(context3)).to be_nil
-    end
-  end
-end