decision_agent 0.2.0 → 1.0.1

data/spec/edge_cases_spec.rb

@@ -1,353 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "Edge Cases" do
-  describe "missing fields in context" do
-    it "handles missing fields gracefully in rule evaluation" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "missing_field", op: "eq", value: "value" },
-            then: { decision: "approve" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      context = DecisionAgent::Context.new({})
-
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation).to be_nil
-    end
-
-    it "handles nil values in comparisons" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "value", op: "gt", value: 10 },
-            then: { decision: "approve" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      context = DecisionAgent::Context.new({ value: nil })
-
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation).to be_nil
-    end
-  end
-
-  describe "confidence edge cases" do
-    it "raises error when confidence exceeds 1.0" do
-      expect do
-        DecisionAgent::Decision.new(
-          decision: "test",
-          confidence: 1.5,
-          explanations: [],
-          evaluations: [],
-          audit_payload: {}
-        )
-      end.to raise_error(DecisionAgent::InvalidConfidenceError)
-    end
-
-    it "raises error when confidence is negative" do
-      expect do
-        DecisionAgent::Decision.new(
-          decision: "test",
-          confidence: -0.1,
-          explanations: [],
-          evaluations: [],
-          audit_payload: {}
-        )
-      end.to raise_error(DecisionAgent::InvalidConfidenceError)
-    end
-
-    it "accepts confidence at boundary values" do
-      decision0 = DecisionAgent::Decision.new(
-        decision: "test",
-        confidence: 0.0,
-        explanations: [],
-        evaluations: [],
-        audit_payload: {}
-      )
-
-      decision1 = DecisionAgent::Decision.new(
-        decision: "test",
-        confidence: 1.0,
-        explanations: [],
-        evaluations: [],
-        audit_payload: {}
-      )
-
-      expect(decision0.confidence).to eq(0.0)
-      expect(decision1.confidence).to eq(1.0)
-    end
-  end
-
-  describe "weight edge cases" do
-    it "raises error when weight exceeds 1.0" do
-      expect do
-        DecisionAgent::Evaluation.new(
-          decision: "test",
-          weight: 1.5,
-          reason: "test",
-          evaluator_name: "test"
-        )
-      end.to raise_error(DecisionAgent::InvalidWeightError)
-    end
-
-    it "raises error when weight is negative" do
-      expect do
-        DecisionAgent::Evaluation.new(
-          decision: "test",
-          weight: -0.1,
-          reason: "test",
-          evaluator_name: "test"
-        )
-      end.to raise_error(DecisionAgent::InvalidWeightError)
-    end
-
-    it "accepts weight at boundary values" do
-      eval0 = DecisionAgent::Evaluation.new(
-        decision: "test",
-        weight: 0.0,
-        reason: "test",
-        evaluator_name: "test"
-      )
-
-      eval1 = DecisionAgent::Evaluation.new(
-        decision: "test",
-        weight: 1.0,
-        reason: "test",
-        evaluator_name: "test"
-      )
-
-      expect(eval0.weight).to eq(0.0)
-      expect(eval1.weight).to eq(1.0)
-    end
-  end
-
-  describe "empty arrays and collections" do
-    it "handles rules with empty 'all' conditions" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { all: [] },
-            then: { decision: "approve" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      context = DecisionAgent::Context.new({})
-
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation).not_to be_nil
-    end
-
-    it "handles rules with empty 'any' conditions" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { any: [] },
-            then: { decision: "approve" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      context = DecisionAgent::Context.new({})
-
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation).to be_nil
-    end
-  end
-
-  describe "type mismatches in comparisons" do
-    it "handles type mismatches in numeric comparisons" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "value", op: "gt", value: 10 },
-            then: { decision: "approve" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      context = DecisionAgent::Context.new({ value: "not_a_number" })
-
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation).to be_nil
-    end
-  end
-
-  describe "immutability" do
-    it "freezes context data to prevent modification" do
-      context = DecisionAgent::Context.new({ user: "alice" })
-
-      expect do
-        context.to_h[:user] = "bob"
-      end.to raise_error(FrozenError)
-    end
-
-    it "freezes evaluation fields" do
-      evaluation = DecisionAgent::Evaluation.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "test",
-        evaluator_name: "test"
-      )
-
-      expect(evaluation.decision).to be_frozen
-      expect(evaluation.reason).to be_frozen
-      expect(evaluation.evaluator_name).to be_frozen
-    end
-
-    it "freezes decision fields" do
-      decision = DecisionAgent::Decision.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: ["test"],
-        evaluations: [],
-        audit_payload: {}
-      )
-
-      expect(decision.decision).to be_frozen
-      expect(decision.explanations).to be_frozen
-    end
-  end
-
-  describe "special characters and unicode" do
-    it "handles unicode in context values" do
-      context = DecisionAgent::Context.new({ user: "用户", message: "Hello 世界" })
-
-      evaluator = DecisionAgent::Evaluators::StaticEvaluator.new(decision: "approve")
-      agent = DecisionAgent::Agent.new(evaluators: [evaluator])
-
-      result = agent.decide(context: context)
-
-      expect(result.audit_payload[:context][:user]).to eq("用户")
-    end
-
-    it "handles special characters in rule values" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "symbol", op: "eq", value: "@#$%^&*()" },
-            then: { decision: "special" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      context = DecisionAgent::Context.new({ symbol: "@#$%^&*()" })
-
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation).not_to be_nil
-      expect(evaluation.decision).to eq("special")
-    end
-  end
-
-  describe "very large numbers and values" do
-    it "handles large numeric values in comparisons" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "amount", op: "gte", value: 1_000_000_000 },
-            then: { decision: "large_amount" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      context = DecisionAgent::Context.new({ amount: 5_000_000_000 })
-
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation).not_to be_nil
-      expect(evaluation.decision).to eq("large_amount")
-    end
-  end
-
-  describe "deeply nested context" do
-    it "handles deeply nested field access" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "rule_1",
-            if: { field: "a.b.c.d.e", op: "eq", value: "deep" },
-            then: { decision: "found_deep" }
-          }
-        ]
-      }
-
-      evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      context = DecisionAgent::Context.new({
-                                             a: {
-                                               b: {
-                                                 c: {
-                                                   d: {
-                                                     e: "deep"
-                                                   }
-                                                 }
-                                               }
-                                             }
-                                           })
-
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation).not_to be_nil
-      expect(evaluation.decision).to eq("found_deep")
-    end
-  end
-
-  describe "audit adapter errors" do
-    it "propagates errors from audit adapter" do
-      failing_adapter = Class.new(DecisionAgent::Audit::Adapter) do
-        def record(_decision, _context)
-          raise StandardError, "Audit failed"
-        end
-      end
-
-      evaluator = DecisionAgent::Evaluators::StaticEvaluator.new(decision: "approve")
-      agent = DecisionAgent::Agent.new(
-        evaluators: [evaluator],
-        audit_adapter: failing_adapter.new
-      )
-
-      expect do
-        agent.decide(context: {})
-      end.to raise_error(StandardError, "Audit failed")
-    end
-  end
-end

data/spec/evaluation_spec.rb

@@ -1,364 +0,0 @@
-require "spec_helper"
-
-RSpec.describe DecisionAgent::Evaluation do
-  describe "#initialize" do
-    it "creates an evaluation with all required fields" do
-      evaluation = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test reason",
-        evaluator_name: "TestEvaluator"
-      )
-
-      expect(evaluation.decision).to eq("approve")
-      expect(evaluation.weight).to eq(0.8)
-      expect(evaluation.reason).to eq("Test reason")
-      expect(evaluation.evaluator_name).to eq("TestEvaluator")
-      expect(evaluation.metadata).to eq({})
-    end
-
-    it "converts decision to string" do
-      evaluation = described_class.new(
-        decision: :approve,
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Test"
-      )
-
-      expect(evaluation.decision).to eq("approve")
-    end
-
-    it "converts weight to float" do
-      evaluation = described_class.new(
-        decision: "approve",
-        weight: "0.8",
-        reason: "Test",
-        evaluator_name: "Test"
-      )
-
-      expect(evaluation.weight).to eq(0.8)
-    end
-
-    it "converts reason to string" do
-      evaluation = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: :test_reason,
-        evaluator_name: "Test"
-      )
-
-      expect(evaluation.reason).to eq("test_reason")
-    end
-
-    it "converts evaluator_name to string" do
-      evaluation = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: :TestEvaluator
-      )
-
-      expect(evaluation.evaluator_name).to eq("TestEvaluator")
-    end
-
-    it "freezes the evaluation object" do
-      evaluation = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Test"
-      )
-
-      expect(evaluation).to be_frozen
-    end
-
-    it "freezes nested structures" do
-      evaluation = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Test",
-        metadata: { key: "value", nested: { data: [1, 2, 3] } }
-      )
-
-      expect(evaluation.decision).to be_frozen
-      expect(evaluation.reason).to be_frozen
-      expect(evaluation.evaluator_name).to be_frozen
-      expect(evaluation.metadata).to be_frozen
-      expect(evaluation.metadata[:nested]).to be_frozen
-      expect(evaluation.metadata[:nested][:data]).to be_frozen
-    end
-
-    it "freezes metadata in-place without creating new objects" do
-      original_metadata = { key: "value", nested: { data: [1, 2, 3] } }
-      original_metadata_id = original_metadata.object_id
-      original_nested_id = original_metadata[:nested].object_id
-
-      evaluation = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Test",
-        metadata: original_metadata
-      )
-
-      # Should freeze in-place, not create new objects
-      expect(evaluation.metadata.object_id).to eq(original_metadata_id)
-      expect(evaluation.metadata[:nested].object_id).to eq(original_nested_id)
-      expect(evaluation.metadata).to be_frozen
-      expect(evaluation.metadata[:nested]).to be_frozen
-    end
-
-    it "skips already frozen objects in deep_freeze" do
-      frozen_metadata = { key: "value", nested: { data: [1, 2, 3] } }
-      frozen_metadata.freeze
-      frozen_metadata[:nested].freeze
-
-      evaluation = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Test",
-        metadata: frozen_metadata
-      )
-
-      expect(evaluation.metadata).to be_frozen
-      expect(evaluation.metadata[:nested]).to be_frozen
-    end
-
-    it "does not freeze hash keys unnecessarily" do
-      key_symbol = :test_key
-      key_string = "test_key"
-      metadata = {
-        key_symbol => "value1",
-        key_string => "value2"
-      }
-
-      evaluation = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Test",
-        metadata: metadata
-      )
-
-      # Keys should not be frozen (they're typically symbols/strings that don't need freezing)
-      expect(evaluation.metadata.keys.first).to eq(key_symbol)
-      expect(evaluation.metadata.keys.last).to eq(key_string)
-      # Values should be frozen
-      expect(evaluation.metadata[key_symbol]).to be_frozen
-      expect(evaluation.metadata[key_string]).to be_frozen
-    end
-
-    it "raises error for weight outside 0-1 range" do
-      expect do
-        described_class.new(
-          decision: "approve",
-          weight: 1.5,
-          reason: "Test",
-          evaluator_name: "Test"
-        )
-      end.to raise_error(DecisionAgent::InvalidWeightError)
-    end
-
-    it "raises error for negative weight" do
-      expect do
-        described_class.new(
-          decision: "approve",
-          weight: -0.1,
-          reason: "Test",
-          evaluator_name: "Test"
-        )
-      end.to raise_error(DecisionAgent::InvalidWeightError)
-    end
-
-    it "accepts weight at boundaries" do
-      eval1 = described_class.new(
-        decision: "approve",
-        weight: 0.0,
-        reason: "Test",
-        evaluator_name: "Test"
-      )
-      expect(eval1.weight).to eq(0.0)
-
-      eval2 = described_class.new(
-        decision: "approve",
-        weight: 1.0,
-        reason: "Test",
-        evaluator_name: "Test"
-      )
-      expect(eval2.weight).to eq(1.0)
-    end
-
-    it "handles metadata" do
-      metadata = { rule_id: "rule_1", source: "test" }
-      evaluation = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Test",
-        metadata: metadata
-      )
-
-      expect(evaluation.metadata).to eq(metadata)
-    end
-
-    it "defaults to empty metadata" do
-      evaluation = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Test"
-      )
-
-      expect(evaluation.metadata).to eq({})
-    end
-  end
-
-  describe "#to_h" do
-    it "converts evaluation to hash" do
-      evaluation = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test reason",
-        evaluator_name: "TestEvaluator",
-        metadata: { key: "value" }
-      )
-
-      hash = evaluation.to_h
-
-      expect(hash).to be_a(Hash)
-      expect(hash[:decision]).to eq("approve")
-      expect(hash[:weight]).to eq(0.8)
-      expect(hash[:reason]).to eq("Test reason")
-      expect(hash[:evaluator_name]).to eq("TestEvaluator")
-      expect(hash[:metadata]).to eq({ key: "value" })
-    end
-  end
-
-  describe "#==" do
-    it "compares evaluations by all fields" do
-      eval1 = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Test",
-        metadata: { key: "value" }
-      )
-
-      eval2 = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Test",
-        metadata: { key: "value" }
-      )
-
-      expect(eval1).to eq(eval2)
-    end
-
-    it "returns false for different decisions" do
-      eval1 = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Test"
-      )
-
-      eval2 = described_class.new(
-        decision: "reject",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Test"
-      )
-
-      expect(eval1).not_to eq(eval2)
-    end
-
-    it "returns false for different weights" do
-      eval1 = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Test"
-      )
-
-      eval2 = described_class.new(
-        decision: "approve",
-        weight: 0.9,
-        reason: "Test",
-        evaluator_name: "Test"
-      )
-
-      expect(eval1).not_to eq(eval2)
-    end
-
-    it "returns false for different reasons" do
-      eval1 = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Reason 1",
-        evaluator_name: "Test"
-      )
-
-      eval2 = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Reason 2",
-        evaluator_name: "Test"
-      )
-
-      expect(eval1).not_to eq(eval2)
-    end
-
-    it "returns false for different evaluator names" do
-      eval1 = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Evaluator1"
-      )
-
-      eval2 = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Evaluator2"
-      )
-
-      expect(eval1).not_to eq(eval2)
-    end
-
-    it "returns false for different metadata" do
-      eval1 = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Test",
-        metadata: { key: "value1" }
-      )
-
-      eval2 = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Test",
-        metadata: { key: "value2" }
-      )
-
-      expect(eval1).not_to eq(eval2)
-    end
-
-    it "returns false for non-Evaluation objects" do
-      evaluation = described_class.new(
-        decision: "approve",
-        weight: 0.8,
-        reason: "Test",
-        evaluator_name: "Test"
-      )
-
-      expect(evaluation).not_to eq("not an evaluation")
-      expect(evaluation).not_to eq(nil)
-    end
-  end
-end