decision_agent 0.3.0 → 1.0.1

data/spec/dmn/hit_policy_spec.rb

@@ -1,202 +0,0 @@
-require "spec_helper"
-require "decision_agent"
-require "decision_agent/dmn/model"
-require "decision_agent/evaluators/dmn_evaluator"
-
-RSpec.describe "DMN Hit Policies" do
-  let(:model) { DecisionAgent::Dmn::Model.new(id: "test_model", name: "Test Model") }
-
-  def create_decision_table(hit_policy, rules_data)
-    table = DecisionAgent::Dmn::DecisionTable.new(id: "test_table", hit_policy: hit_policy)
-
-    # Add inputs
-    table.add_input(DecisionAgent::Dmn::Input.new(id: "input1", label: "value"))
-    table.add_output(DecisionAgent::Dmn::Output.new(id: "output1", label: "decision", name: "decision"))
-
-    # Add rules
-    rules_data.each do |rule_data|
-      rule = DecisionAgent::Dmn::Rule.new(id: rule_data[:id], description: rule_data[:description])
-      rule.add_input_entry(rule_data[:input])
-      rule.add_output_entry(rule_data[:output])
-      table.add_rule(rule)
-    end
-
-    decision = DecisionAgent::Dmn::Decision.new(id: "test_decision", name: "Test Decision")
-    decision.decision_table = table
-    model.add_decision(decision)
-
-    table
-  end
-
-  describe "UNIQUE hit policy" do
-    it "returns result when exactly one rule matches" do
-      create_decision_table("UNIQUE", [
-                              { id: "rule1", input: ">= 10", output: '"approved"', description: "High value" },
-                              { id: "rule2", input: "< 10", output: '"rejected"', description: "Low value" }
-                            ])
-
-      evaluator = DecisionAgent::Evaluators::DmnEvaluator.new(
-        model: model,
-        decision_id: "test_decision"
-      )
-
-      evaluation = evaluator.evaluate(DecisionAgent::Context.new(value: 15))
-      expect(evaluation).not_to be_nil
-      expect(evaluation.decision).to eq("approved")
-    end
-
-    it "raises error when no rules match" do
-      create_decision_table("UNIQUE", [
-                              { id: "rule1", input: ">= 10", output: '"approved"', description: "High value" },
-                              { id: "rule2", input: "> 20", output: '"rejected"', description: "Very high value" }
-                            ])
-
-      evaluator = DecisionAgent::Evaluators::DmnEvaluator.new(
-        model: model,
-        decision_id: "test_decision"
-      )
-
-      # Value 5 doesn't match >= 10 or > 20, so no rules match
-      expect do
-        evaluator.evaluate(DecisionAgent::Context.new(value: 5))
-      end.to raise_error(DecisionAgent::Dmn::InvalidDmnModelError, /UNIQUE hit policy requires exactly one matching rule/)
-    end
-
-    it "raises error when multiple rules match" do
-      create_decision_table("UNIQUE", [
-                              { id: "rule1", input: ">= 5", output: '"approved"', description: "Rule 1" },
-                              { id: "rule2", input: ">= 10", output: '"approved"', description: "Rule 2" }
-                            ])
-
-      evaluator = DecisionAgent::Evaluators::DmnEvaluator.new(
-        model: model,
-        decision_id: "test_decision"
-      )
-
-      expect do
-        evaluator.evaluate(DecisionAgent::Context.new(value: 15))
-      end.to raise_error(DecisionAgent::Dmn::InvalidDmnModelError, /UNIQUE hit policy requires exactly one matching rule, but 2 matched/)
-    end
-  end
-
-  describe "FIRST hit policy" do
-    it "returns first matching rule when multiple rules match" do
-      create_decision_table("FIRST", [
-                              { id: "rule1", input: ">= 5", output: '"first"', description: "First rule" },
-                              { id: "rule2", input: ">= 10", output: '"second"', description: "Second rule" }
-                            ])
-
-      evaluator = DecisionAgent::Evaluators::DmnEvaluator.new(
-        model: model,
-        decision_id: "test_decision"
-      )
-
-      evaluation = evaluator.evaluate(DecisionAgent::Context.new(value: 15))
-      expect(evaluation).not_to be_nil
-      expect(evaluation.decision).to eq("first")
-      expect(evaluation.metadata[:rule_id]).to eq("rule1")
-    end
-
-    it "returns nil when no rules match" do
-      create_decision_table("FIRST", [
-                              { id: "rule1", input: ">= 10", output: '"approved"', description: "High value" }
-                            ])
-
-      evaluator = DecisionAgent::Evaluators::DmnEvaluator.new(
-        model: model,
-        decision_id: "test_decision"
-      )
-
-      evaluation = evaluator.evaluate(DecisionAgent::Context.new(value: 5))
-      expect(evaluation).to be_nil
-    end
-  end
-
-  describe "PRIORITY hit policy" do
-    it "returns first matching rule (rule order determines priority)" do
-      create_decision_table("PRIORITY", [
-                              { id: "rule1", input: ">= 5", output: '"high_priority"', description: "High priority rule" },
-                              { id: "rule2", input: ">= 10", output: '"low_priority"', description: "Low priority rule" }
-                            ])
-
-      evaluator = DecisionAgent::Evaluators::DmnEvaluator.new(
-        model: model,
-        decision_id: "test_decision"
-      )
-
-      evaluation = evaluator.evaluate(DecisionAgent::Context.new(value: 15))
-      expect(evaluation).not_to be_nil
-      expect(evaluation.decision).to eq("high_priority")
-      expect(evaluation.metadata[:rule_id]).to eq("rule1")
-    end
-  end
-
-  describe "ANY hit policy" do
-    it "returns result when all matching rules have same output" do
-      create_decision_table("ANY", [
-                              { id: "rule1", input: ">= 5", output: '"approved"', description: "Rule 1" },
-                              { id: "rule2", input: ">= 10", output: '"approved"', description: "Rule 2" }
-                            ])
-
-      evaluator = DecisionAgent::Evaluators::DmnEvaluator.new(
-        model: model,
-        decision_id: "test_decision"
-      )
-
-      evaluation = evaluator.evaluate(DecisionAgent::Context.new(value: 15))
-      expect(evaluation).not_to be_nil
-      expect(evaluation.decision).to eq("approved")
-    end
-
-    it "raises error when matching rules have different outputs" do
-      create_decision_table("ANY", [
-                              { id: "rule1", input: ">= 5", output: '"approved"', description: "Rule 1" },
-                              { id: "rule2", input: ">= 10", output: '"rejected"', description: "Rule 2" }
-                            ])
-
-      evaluator = DecisionAgent::Evaluators::DmnEvaluator.new(
-        model: model,
-        decision_id: "test_decision"
-      )
-
-      expect do
-        evaluator.evaluate(DecisionAgent::Context.new(value: 15))
-      end.to raise_error(DecisionAgent::Dmn::InvalidDmnModelError, /ANY hit policy requires all matching rules to have the same output/)
-    end
-  end
-
-  describe "COLLECT hit policy" do
-    it "returns first match with metadata about all matches" do
-      create_decision_table("COLLECT", [
-                              { id: "rule1", input: ">= 5", output: '"match1"', description: "Rule 1" },
-                              { id: "rule2", input: ">= 10", output: '"match2"', description: "Rule 2" }
-                            ])
-
-      evaluator = DecisionAgent::Evaluators::DmnEvaluator.new(
-        model: model,
-        decision_id: "test_decision"
-      )
-
-      evaluation = evaluator.evaluate(DecisionAgent::Context.new(value: 15))
-      expect(evaluation).not_to be_nil
-      expect(evaluation.decision).to eq("match1")
-      expect(evaluation.metadata[:collect_count]).to eq(2)
-      expect(evaluation.metadata[:collect_decisions]).to eq(%w[match1 match2])
-      expect(evaluation.metadata[:collect_rule_ids]).to eq(%w[rule1 rule2])
-    end
-
-    it "returns nil when no rules match" do
-      create_decision_table("COLLECT", [
-                              { id: "rule1", input: ">= 10", output: '"approved"', description: "High value" }
-                            ])
-
-      evaluator = DecisionAgent::Evaluators::DmnEvaluator.new(
-        model: model,
-        decision_id: "test_decision"
-      )
-
-      evaluation = evaluator.evaluate(DecisionAgent::Context.new(value: 5))
-      expect(evaluation).to be_nil
-    end
-  end
-end

data/spec/dmn/integration_spec.rb

@@ -1,226 +0,0 @@
-require "spec_helper"
-require "decision_agent"
-require "decision_agent/dmn/importer"
-require "decision_agent/dmn/exporter"
-require "decision_agent/evaluators/dmn_evaluator"
-require "tempfile"
-require "fileutils"
-
-RSpec.describe "DMN Integration" do
-  let(:simple_dmn_path) { File.expand_path("../fixtures/dmn/simple_decision.dmn", __dir__) }
-  let(:complex_dmn_path) { File.expand_path("../fixtures/dmn/complex_decision.dmn", __dir__) }
-  let(:invalid_dmn_path) { File.expand_path("../fixtures/dmn/invalid_structure.dmn", __dir__) }
-
-  # Create temporary directory for file storage adapter
-  let(:temp_dir) { Dir.mktmpdir }
-  let(:version_manager) do
-    DecisionAgent::Versioning::VersionManager.new(
-      adapter: DecisionAgent::Versioning::FileStorageAdapter.new(storage_path: temp_dir)
-    )
-  end
-
-  after do
-    FileUtils.rm_rf(temp_dir)
-  end
-
-  describe "import and execute simple decision" do
-    it "imports DMN file and makes decisions" do
-      # Import
-      importer = DecisionAgent::Dmn::Importer.new(version_manager: version_manager)
-      result = importer.import(simple_dmn_path, created_by: "test")
-
-      expect(result[:decisions_imported]).to eq(1)
-      expect(result[:model]).to be_a(DecisionAgent::Dmn::Model)
-      expect(result[:model].decisions.size).to eq(1)
-
-      # Create evaluator
-      evaluator = DecisionAgent::Evaluators::DmnEvaluator.new(
-        model: result[:model],
-        decision_id: "age_check"
-      )
-
-      # Test approval case (age >= 18)
-      context_approve = DecisionAgent::Context.new({ age: 25 })
-      evaluation_approve = evaluator.evaluate(context_approve)
-
-      expect(evaluation_approve).not_to be_nil
-      expect(evaluation_approve.decision).to eq("approve")
-      expect(evaluation_approve.evaluator_name).to include("DmnEvaluator")
-
-      # Test rejection case (age < 18)
-      context_reject = DecisionAgent::Context.new({ age: 15 })
-      evaluation_reject = evaluator.evaluate(context_reject)
-
-      expect(evaluation_reject).not_to be_nil
-      expect(evaluation_reject.decision).to eq("reject")
-    end
-  end
-
-  describe "import and execute complex decision" do
-    it "handles multi-input decision tables" do
-      # Import
-      importer = DecisionAgent::Dmn::Importer.new(version_manager: version_manager)
-      result = importer.import(complex_dmn_path, created_by: "test")
-
-      expect(result[:decisions_imported]).to eq(1)
-
-      # Create evaluator
-      evaluator = DecisionAgent::Evaluators::DmnEvaluator.new(
-        model: result[:model],
-        decision_id: "loan_approval"
-      )
-
-      # Test excellent case
-      context_excellent = DecisionAgent::Context.new({
-                                                       credit_score: 800,
-                                                       income: 75_000,
-                                                       loan_amount: 150_000
-                                                     })
-      evaluation_excellent = evaluator.evaluate(context_excellent)
-
-      expect(evaluation_excellent).not_to be_nil
-      expect(evaluation_excellent.decision).to eq("approve")
-
-      # Test good case
-      context_good = DecisionAgent::Context.new({
-                                                  credit_score: 700,
-                                                  income: 45_000,
-                                                  loan_amount: 100_000
-                                                })
-      evaluation_good = evaluator.evaluate(context_good)
-
-      expect(evaluation_good).not_to be_nil
-      expect(evaluation_good.decision).to eq("conditional_approve")
-
-      # Test rejection case
-      context_reject = DecisionAgent::Context.new({
-                                                    credit_score: 500,
-                                                    income: 25_000,
-                                                    loan_amount: 100_000
-                                                  })
-      evaluation_reject = evaluator.evaluate(context_reject)
-
-      expect(evaluation_reject).not_to be_nil
-      expect(evaluation_reject.decision).to eq("reject")
-    end
-  end
-
-  describe "invalid DMN handling" do
-    it "validates and rejects invalid DMN structure" do
-      importer = DecisionAgent::Dmn::Importer.new(version_manager: version_manager)
-
-      expect do
-        importer.import(invalid_dmn_path, created_by: "test")
-      end.to raise_error(DecisionAgent::Dmn::InvalidDmnModelError, /Expected 1 input entries, got 2/)
-    end
-  end
-
-  describe "round-trip conversion" do
-    it "preserves structure through import-export-import cycle" do
-      # Import original
-      importer = DecisionAgent::Dmn::Importer.new(version_manager: version_manager)
-      original = importer.import(simple_dmn_path, ruleset_name: "age_check_v1", created_by: "test")
-
-      expect(original[:decisions_imported]).to eq(1)
-
-      # Export
-      exporter = DecisionAgent::Dmn::Exporter.new(version_manager: version_manager)
-      exported_xml = exporter.export("age_check_v1")
-
-      expect(exported_xml).to include('xmlns="https://www.omg.org/spec/DMN/20191111/MODEL/"')
-      expect(exported_xml).to include("<decision")
-      expect(exported_xml).to include("<decisionTable")
-
-      # Re-import
-      reimported = importer.import_from_xml(exported_xml, ruleset_name: "age_check_v2", created_by: "test")
-
-      # Compare structures
-      expect(reimported[:model].decisions.size).to eq(original[:model].decisions.size)
-      expect(reimported[:decisions_imported]).to eq(original[:decisions_imported])
-
-      # Verify it still works
-      evaluator = DecisionAgent::Evaluators::DmnEvaluator.new(
-        model: reimported[:model],
-        decision_id: reimported[:model].decisions.first.id
-      )
-
-      context = DecisionAgent::Context.new({ age: 25 })
-      evaluation = evaluator.evaluate(context)
-
-      expect(evaluation).not_to be_nil
-      expect(evaluation.decision).to eq("approve")
-    end
-  end
-
-  describe "combining with JSON evaluators" do
-    it "works alongside JsonRuleEvaluator in same agent" do
-      # Load DMN
-      importer = DecisionAgent::Dmn::Importer.new(version_manager: version_manager)
-      dmn_result = importer.import(simple_dmn_path, created_by: "test")
-
-      dmn_evaluator = DecisionAgent::Evaluators::DmnEvaluator.new(
-        model: dmn_result[:model],
-        decision_id: "age_check"
-      )
-
-      # Create JSON evaluator
-      json_rules = {
-        version: "1.0",
-        ruleset: "json_rules",
-        rules: [
-          {
-            id: "priority_rule",
-            if: { field: "priority", op: "eq", value: "high" },
-            then: { decision: "escalate", weight: 0.9, reason: "High priority escalation" }
-          }
-        ]
-      }
-
-      json_evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(
-        rules_json: json_rules
-      )
-
-      # Use both in agent
-      agent = DecisionAgent::Agent.new(
-        evaluators: [dmn_evaluator, json_evaluator]
-      )
-
-      # Test with context matching both evaluators
-      decision = agent.decide(
-        context: { age: 25, priority: "high" }
-      )
-
-      expect(%w[approve escalate]).to include(decision.decision)
-      expect(decision.evaluations.size).to eq(2)
-      expect(decision.evaluations.map(&:evaluator_name)).to include(
-        match(/DmnEvaluator/),
-        match(/JsonRuleEvaluator/)
-      )
-    end
-  end
-
-  describe "versioning integration" do
-    it "stores and retrieves DMN models from versioning system" do
-      importer = DecisionAgent::Dmn::Importer.new(version_manager: version_manager)
-
-      # Import first version
-      v1 = importer.import(simple_dmn_path, ruleset_name: "age_check", created_by: "test_user")
-
-      expect(v1[:versions].size).to eq(1)
-      expect(v1[:versions].first[:rule_id]).to eq("age_check")
-
-      # Get active version
-      active = version_manager.get_active_version(rule_id: "age_check")
-      expect(active).not_to be_nil
-      expect(active[:content]).to be_a(Hash)
-      # Content may have string or symbol keys depending on storage adapter
-      rules = active[:content]["rules"] || active[:content][:rules]
-      expect(rules).to be_an(Array)
-
-      # Get version history
-      versions = version_manager.get_versions(rule_id: "age_check")
-      expect(versions.size).to eq(1)
-      expect(versions.first[:created_by]).to eq("test_user")
-    end
-  end
-end