decision_agent 0.1.4 → 0.1.6

data/spec/ab_testing/ab_testing_agent_spec.rb

@@ -0,0 +1,481 @@
+require "spec_helper"
+
+RSpec.describe DecisionAgent::ABTesting::ABTestingAgent do
+  let(:version_manager) { double("VersionManager") }
+  let(:ab_test_manager) { double("ABTestManager", version_manager: version_manager) }
+  let(:base_evaluator) do
+    DecisionAgent::Evaluators::StaticEvaluator.new(
+      decision: "approve",
+      weight: 0.8,
+      reason: "Base evaluator"
+    )
+  end
+
+  describe "#initialize" do
+    it "initializes with ab_test_manager" do
+      agent = described_class.new(ab_test_manager: ab_test_manager)
+      expect(agent.ab_test_manager).to eq(ab_test_manager)
+    end
+
+    it "uses version_manager from ab_test_manager if not provided" do
+      allow(ab_test_manager).to receive(:version_manager).and_return(version_manager)
+      agent = described_class.new(ab_test_manager: ab_test_manager)
+      expect(agent.version_manager).to eq(version_manager)
+    end
+
+    it "uses provided version_manager" do
+      custom_version_manager = double("CustomVersionManager")
+      agent = described_class.new(
+        ab_test_manager: ab_test_manager,
+        version_manager: custom_version_manager
+      )
+      expect(agent.version_manager).to eq(custom_version_manager)
+    end
+  end
+
+  describe "#decide" do
+    context "without A/B test" do
+      it "makes standard decision" do
+        agent = described_class.new(
+          ab_test_manager: ab_test_manager,
+          evaluators: [base_evaluator]
+        )
+
+        result = agent.decide(context: { user: "test" })
+
+        expect(result[:decision]).to eq("approve")
+        expect(result[:ab_test]).to be_nil
+      end
+    end
+
+    context "with A/B test" do
+      let(:assignment) do
+        {
+          assignment_id: "assign_1",
+          variant: "A",
+          version_id: "version_1"
+        }
+      end
+
+      let(:version) do
+        {
+          content: {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "status", op: "eq", value: "active" },
+                then: { decision: "approve", weight: 0.9 }
+              }
+            ]
+          }
+        }
+      end
+
+      before do
+        allow(ab_test_manager).to receive(:assign_variant).and_return(assignment)
+        allow(version_manager).to receive(:get_version).and_return(version)
+        allow(ab_test_manager).to receive(:record_decision)
+      end
+
+      it "assigns variant and makes decision" do
+        agent = described_class.new(
+          ab_test_manager: ab_test_manager,
+          version_manager: version_manager
+        )
+
+        result = agent.decide(
+          context: { status: "active" },
+          ab_test_id: "test_1",
+          user_id: "user_1"
+        )
+
+        expect(result[:decision]).to eq("approve")
+        expect(result[:ab_test]).not_to be_nil
+        expect(result[:ab_test][:test_id]).to eq("test_1")
+        expect(result[:ab_test][:variant]).to eq("A")
+      end
+
+      it "raises error if version not found" do
+        allow(version_manager).to receive(:get_version).and_return(nil)
+        agent = described_class.new(
+          ab_test_manager: ab_test_manager,
+          version_manager: version_manager
+        )
+
+        expect do
+          agent.decide(
+            context: { status: "active" },
+            ab_test_id: "test_1"
+          )
+        end.to raise_error(DecisionAgent::ABTesting::VersionNotFoundError)
+      end
+
+      it "records decision result" do
+        agent = described_class.new(
+          ab_test_manager: ab_test_manager,
+          version_manager: version_manager
+        )
+
+        agent.decide(
+          context: { status: "active" },
+          ab_test_id: "test_1"
+        )
+
+        expect(ab_test_manager).to have_received(:record_decision).with(
+          assignment_id: "assign_1",
+          decision: "approve",
+          confidence: be_a(Numeric)
+        )
+      end
+    end
+  end
+
+  describe "#get_test_results" do
+    it "delegates to ab_test_manager" do
+      agent = described_class.new(ab_test_manager: ab_test_manager)
+      allow(ab_test_manager).to receive(:get_results).and_return({ results: [] })
+
+      result = agent.get_test_results("test_1")
+
+      expect(ab_test_manager).to have_received(:get_results).with("test_1")
+      expect(result).to eq({ results: [] })
+    end
+  end
+
+  describe "#active_tests" do
+    it "delegates to ab_test_manager" do
+      agent = described_class.new(ab_test_manager: ab_test_manager)
+      allow(ab_test_manager).to receive(:active_tests).and_return([])
+
+      result = agent.active_tests
+
+      expect(ab_test_manager).to have_received(:active_tests)
+      expect(result).to eq([])
+    end
+  end
+
+  describe "#decide with feedback" do
+    it "passes feedback to agent" do
+      agent = described_class.new(
+        ab_test_manager: ab_test_manager,
+        evaluators: [base_evaluator]
+      )
+
+      result = agent.decide(context: { user: "test" }, feedback: { rating: 5 })
+
+      expect(result[:decision]).to eq("approve")
+    end
+  end
+
+  describe "#decide with A/B test - evaluator building" do
+    let(:assignment) do
+      {
+        assignment_id: "assign_1",
+        variant: "A",
+        version_id: "version_1"
+      }
+    end
+
+    let(:version_with_rules) do
+      {
+        content: {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "status", op: "eq", value: "active" },
+              then: { decision: "approve", weight: 0.9 }
+            }
+          ]
+        }
+      }
+    end
+
+    let(:version_with_evaluators) do
+      {
+        content: {
+          evaluators: [
+            {
+              type: "json_rule",
+              rules: {
+                version: "1.0",
+                ruleset: "test",
+                rules: [
+                  {
+                    id: "rule_1",
+                    if: { field: "status", op: "eq", value: "active" },
+                    then: { decision: "approve", weight: 0.9 }
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      }
+    end
+
+    let(:version_with_static_evaluator) do
+      {
+        content: {
+          evaluators: [
+            {
+              type: "static",
+              decision: "reject",
+              weight: 0.5,
+              reason: "Static test"
+            }
+          ]
+        }
+      }
+    end
+
+    before do
+      allow(ab_test_manager).to receive(:assign_variant).and_return(assignment)
+      allow(ab_test_manager).to receive(:record_decision)
+    end
+
+    it "builds JsonRuleEvaluator from version with rules" do
+      allow(version_manager).to receive(:get_version).and_return(version_with_rules)
+      agent = described_class.new(
+        ab_test_manager: ab_test_manager,
+        version_manager: version_manager
+      )
+
+      result = agent.decide(
+        context: { status: "active" },
+        ab_test_id: "test_1"
+      )
+
+      expect(result[:decision]).to eq("approve")
+    end
+
+    it "builds evaluators from version with evaluator config" do
+      allow(version_manager).to receive(:get_version).and_return(version_with_evaluators)
+      agent = described_class.new(
+        ab_test_manager: ab_test_manager,
+        version_manager: version_manager
+      )
+
+      result = agent.decide(
+        context: { status: "active" },
+        ab_test_id: "test_1"
+      )
+
+      expect(result[:decision]).to eq("approve")
+    end
+
+    it "builds StaticEvaluator from version config" do
+      allow(version_manager).to receive(:get_version).and_return(version_with_static_evaluator)
+      agent = described_class.new(
+        ab_test_manager: ab_test_manager,
+        version_manager: version_manager
+      )
+
+      result = agent.decide(
+        context: { status: "inactive" },
+        ab_test_id: "test_1"
+      )
+
+      expect(result[:decision]).to eq("reject")
+    end
+
+    it "falls back to base evaluators when version content is invalid" do
+      invalid_version = { content: "invalid" }
+      allow(version_manager).to receive(:get_version).and_return(invalid_version)
+      agent = described_class.new(
+        ab_test_manager: ab_test_manager,
+        version_manager: version_manager,
+        evaluators: [base_evaluator]
+      )
+
+      result = agent.decide(
+        context: { status: "active" },
+        ab_test_id: "test_1"
+      )
+
+      expect(result[:decision]).to eq("approve")
+    end
+
+    it "raises error for unknown evaluator type" do
+      invalid_evaluator_version = {
+        content: {
+          evaluators: [
+            {
+              type: "unknown_type",
+              config: {}
+            }
+          ]
+        }
+      }
+      allow(version_manager).to receive(:get_version).and_return(invalid_evaluator_version)
+      agent = described_class.new(
+        ab_test_manager: ab_test_manager,
+        version_manager: version_manager
+      )
+
+      expect do
+        agent.decide(
+          context: { status: "active" },
+          ab_test_id: "test_1"
+        )
+      end.to raise_error(/Unknown evaluator type/)
+    end
+  end
+
+  describe "#decide with Context object" do
+    it "handles Context object instead of hash" do
+      agent = described_class.new(
+        ab_test_manager: ab_test_manager,
+        evaluators: [base_evaluator]
+      )
+
+      context = DecisionAgent::Context.new({ user: "test" })
+      result = agent.decide(context: context)
+
+      expect(result[:decision]).to eq("approve")
+    end
+  end
+
+  describe "initialization with optional parameters" do
+    it "initializes with scoring_strategy" do
+      scoring_strategy = double("ScoringStrategy")
+      agent = described_class.new(
+        ab_test_manager: ab_test_manager,
+        scoring_strategy: scoring_strategy
+      )
+
+      expect(agent.instance_variable_get(:@scoring_strategy)).to eq(scoring_strategy)
+    end
+
+    it "initializes with audit_adapter" do
+      audit_adapter = double("AuditAdapter")
+      agent = described_class.new(
+        ab_test_manager: ab_test_manager,
+        audit_adapter: audit_adapter
+      )
+
+      expect(agent.instance_variable_get(:@audit_adapter)).to eq(audit_adapter)
+    end
+  end
+
+  describe "#build_agent" do
+    it "uses base evaluators when provided evaluators are empty" do
+      agent = described_class.new(
+        ab_test_manager: ab_test_manager,
+        evaluators: [base_evaluator]
+      )
+
+      # Access private method via send
+      built_agent = agent.send(:build_agent, [])
+      expect(built_agent).to be_a(DecisionAgent::Agent)
+    end
+
+    it "uses provided evaluators when not empty" do
+      custom_evaluator = DecisionAgent::Evaluators::StaticEvaluator.new(
+        decision: "reject",
+        weight: 0.5
+      )
+      agent = described_class.new(
+        ab_test_manager: ab_test_manager,
+        evaluators: [base_evaluator]
+      )
+
+      built_agent = agent.send(:build_agent, [custom_evaluator])
+      expect(built_agent).to be_a(DecisionAgent::Agent)
+    end
+  end
+
+  describe "#build_evaluators_from_version" do
+    it "falls back to base evaluators when content is not a hash" do
+      invalid_version = { content: "not a hash" }
+      allow(version_manager).to receive(:get_version).and_return(invalid_version)
+      agent = described_class.new(
+        ab_test_manager: ab_test_manager,
+        version_manager: version_manager,
+        evaluators: [base_evaluator]
+      )
+
+      evaluators = agent.send(:build_evaluators_from_version, invalid_version)
+      expect(evaluators).to eq([base_evaluator])
+    end
+
+    it "falls back to base evaluators when content hash has no evaluators or rules" do
+      invalid_version = { content: { other_key: "value" } }
+      allow(version_manager).to receive(:get_version).and_return(invalid_version)
+      agent = described_class.new(
+        ab_test_manager: ab_test_manager,
+        version_manager: version_manager,
+        evaluators: [base_evaluator]
+      )
+
+      evaluators = agent.send(:build_evaluators_from_version, invalid_version)
+      expect(evaluators).to eq([base_evaluator])
+    end
+  end
+
+  describe "#build_evaluator_from_config" do
+    it "builds JsonRuleEvaluator from config" do
+      agent = described_class.new(
+        ab_test_manager: ab_test_manager,
+        version_manager: version_manager
+      )
+
+      config = {
+        type: "json_rule",
+        rules: {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "status", op: "eq", value: "active" },
+              then: { decision: "approve", weight: 0.9 }
+            }
+          ]
+        }
+      }
+
+      evaluator = agent.send(:build_evaluator_from_config, config)
+      expect(evaluator).to be_a(DecisionAgent::Evaluators::JsonRuleEvaluator)
+    end
+
+    it "builds StaticEvaluator from config with default weight" do
+      agent = described_class.new(
+        ab_test_manager: ab_test_manager,
+        version_manager: version_manager
+      )
+
+      config = {
+        type: "static",
+        decision: "approve",
+        reason: "Test reason"
+        # weight not provided, should default to 1.0
+      }
+
+      evaluator = agent.send(:build_evaluator_from_config, config)
+      expect(evaluator).to be_a(DecisionAgent::Evaluators::StaticEvaluator)
+      expect(evaluator.decision).to eq("approve")
+    end
+
+    it "builds StaticEvaluator from config with custom weight" do
+      agent = described_class.new(
+        ab_test_manager: ab_test_manager,
+        version_manager: version_manager
+      )
+
+      config = {
+        type: "static",
+        decision: "reject",
+        weight: 0.7,
+        reason: "Custom weight"
+      }
+
+      evaluator = agent.send(:build_evaluator_from_config, config)
+      expect(evaluator).to be_a(DecisionAgent::Evaluators::StaticEvaluator)
+      expect(evaluator.decision).to eq("reject")
+    end
+  end
+end

data/spec/ab_testing/storage/adapter_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+require_relative "../../../lib/decision_agent/ab_testing/storage/adapter"
+
+RSpec.describe DecisionAgent::ABTesting::Storage::Adapter do
+  let(:adapter) { described_class.new }
+
+  describe "#save_test" do
+    it "raises NotImplementedError" do
+      test = double("ABTest")
+      expect { adapter.save_test(test) }.to raise_error(NotImplementedError, /must implement #save_test/)
+    end
+  end
+
+  describe "#get_test" do
+    it "raises NotImplementedError" do
+      expect { adapter.get_test("test_id") }.to raise_error(NotImplementedError, /must implement #get_test/)
+    end
+  end
+
+  describe "#update_test" do
+    it "raises NotImplementedError" do
+      expect { adapter.update_test("test_id", {}) }.to raise_error(NotImplementedError, /must implement #update_test/)
+    end
+  end
+
+  describe "#list_tests" do
+    it "raises NotImplementedError" do
+      expect { adapter.list_tests }.to raise_error(NotImplementedError, /must implement #list_tests/)
+    end
+
+    it "raises NotImplementedError with status filter" do
+      expect { adapter.list_tests(status: "active") }.to raise_error(NotImplementedError, /must implement #list_tests/)
+    end
+
+    it "raises NotImplementedError with limit" do
+      expect { adapter.list_tests(limit: 10) }.to raise_error(NotImplementedError, /must implement #list_tests/)
+    end
+  end
+
+  describe "#save_assignment" do
+    it "raises NotImplementedError" do
+      assignment = double("ABTestAssignment")
+      expect { adapter.save_assignment(assignment) }.to raise_error(NotImplementedError, /must implement #save_assignment/)
+    end
+  end
+
+  describe "#update_assignment" do
+    it "raises NotImplementedError" do
+      expect { adapter.update_assignment("assignment_id", {}) }.to raise_error(NotImplementedError, /must implement #update_assignment/)
+    end
+  end
+
+  describe "#get_assignments" do
+    it "raises NotImplementedError" do
+      expect { adapter.get_assignments("test_id") }.to raise_error(NotImplementedError, /must implement #get_assignments/)
+    end
+  end
+
+  describe "#delete_test" do
+    it "raises NotImplementedError" do
+      expect { adapter.delete_test("test_id") }.to raise_error(NotImplementedError, /must implement #delete_test/)
+    end
+  end
+end