decision_agent 0.2.0 → 1.0.1

data/spec/context_spec.rb

@@ -1,127 +0,0 @@
-require "spec_helper"
-
-RSpec.describe DecisionAgent::Context do
-  describe "#initialize" do
-    it "accepts a hash and freezes it" do
-      context = DecisionAgent::Context.new({ user: "alice" })
-
-      expect(context.to_h).to eq({ user: "alice" })
-      expect(context.to_h).to be_frozen
-    end
-
-    it "converts non-hash to empty hash" do
-      context = DecisionAgent::Context.new("not a hash")
-
-      expect(context.to_h).to eq({})
-    end
-
-    it "deep freezes nested hashes" do
-      data = { user: { name: "alice", roles: ["admin"] } }
-      context = DecisionAgent::Context.new(data)
-
-      expect(context.to_h[:user]).to be_frozen
-      expect(context.to_h[:user][:roles]).to be_frozen
-    end
-
-    it "creates a copy before freezing to avoid mutating original data" do
-      original_data = { user: { name: "alice", roles: ["admin"] } }
-      original_data_id = original_data.object_id
-
-      context = DecisionAgent::Context.new(original_data)
-
-      # Should create a copy (different object_id) to avoid mutating original
-      expect(context.to_h.object_id).not_to eq(original_data_id)
-      expect(context.to_h).to be_frozen
-      expect(context.to_h[:user]).to be_frozen
-      # Original data should not be frozen
-      expect(original_data).not_to be_frozen
-    end
-
-    it "skips already frozen objects in deep_freeze" do
-      frozen_data = { user: { name: "alice", roles: ["admin"] } }
-      frozen_data.freeze
-      frozen_data[:user].freeze
-
-      context = DecisionAgent::Context.new(frozen_data)
-
-      expect(context.to_h).to be_frozen
-      expect(context.to_h[:user]).to be_frozen
-    end
-
-    it "does not freeze hash keys unnecessarily" do
-      key_symbol = :test_key
-      key_string = "test_key"
-      data = {
-        key_symbol => "value1",
-        key_string => "value2"
-      }
-
-      context = DecisionAgent::Context.new(data)
-
-      # Keys should not be frozen (they're typically symbols/strings that don't need freezing)
-      expect(context.to_h.keys.first).to eq(key_symbol)
-      expect(context.to_h.keys.last).to eq(key_string)
-      # Values should be frozen
-      expect(context.to_h[key_symbol]).to be_frozen
-      expect(context.to_h[key_string]).to be_frozen
-    end
-  end
-
-  describe "#[]" do
-    it "retrieves values by key" do
-      context = DecisionAgent::Context.new({ status: "active" })
-
-      expect(context[:status]).to eq("active")
-    end
-
-    it "returns nil for missing keys" do
-      context = DecisionAgent::Context.new({})
-
-      expect(context[:missing]).to be_nil
-    end
-  end
-
-  describe "#fetch" do
-    it "retrieves values by key" do
-      context = DecisionAgent::Context.new({ priority: "high" })
-
-      expect(context.fetch(:priority)).to eq("high")
-    end
-
-    it "returns default for missing keys" do
-      context = DecisionAgent::Context.new({})
-
-      expect(context.fetch(:missing, "default")).to eq("default")
-    end
-  end
-
-  describe "#key?" do
-    it "returns true when key exists" do
-      context = DecisionAgent::Context.new({ user: "alice" })
-
-      expect(context.key?(:user)).to be true
-    end
-
-    it "returns false when key does not exist" do
-      context = DecisionAgent::Context.new({})
-
-      expect(context.key?(:user)).to be false
-    end
-  end
-
-  describe "#==" do
-    it "compares contexts by data equality" do
-      context1 = DecisionAgent::Context.new({ user: "alice" })
-      context2 = DecisionAgent::Context.new({ user: "alice" })
-
-      expect(context1).to eq(context2)
-    end
-
-    it "returns false for different data" do
-      context1 = DecisionAgent::Context.new({ user: "alice" })
-      context2 = DecisionAgent::Context.new({ user: "bob" })
-
-      expect(context1).not_to eq(context2)
-    end
-  end
-end

data/spec/decision_agent_spec.rb

@@ -1,96 +0,0 @@
-require "spec_helper"
-
-RSpec.describe DecisionAgent do
-  before do
-    # Reset permission_checker between tests to avoid leakage
-    DecisionAgent.permission_checker = nil
-  end
-
-  describe ".rbac_config" do
-    it "returns the global RBAC configuration" do
-      expect(DecisionAgent.rbac_config).to be_a(DecisionAgent::Auth::RbacConfig)
-    end
-  end
-
-  describe ".configure_rbac" do
-    context "with adapter_type and options" do
-      it "configures RBAC with adapter type" do
-        result = DecisionAgent.configure_rbac(:default)
-        expect(result).to be_a(DecisionAgent::Auth::RbacConfig)
-        expect(DecisionAgent.rbac_config.adapter).to be_a(DecisionAgent::Auth::RbacAdapter)
-      end
-
-      it "configures RBAC with custom options" do
-        result = DecisionAgent.configure_rbac(:custom,
-                                              can_proc: ->(_user, _permission, _resource) { true },
-                                              has_role_proc: ->(_user, _role) { false },
-                                              active_proc: ->(_user) { true })
-        expect(result).to be_a(DecisionAgent::Auth::RbacConfig)
-      end
-    end
-
-    context "with block" do
-      it "yields the config block" do
-        # Now test setting a custom adapter via block
-        custom_adapter = DecisionAgent::Auth::DefaultAdapter.new
-        result = DecisionAgent.configure_rbac do |config|
-          config.adapter = custom_adapter
-        end
-
-        expect(result).to be_a(DecisionAgent::Auth::RbacConfig)
-        expect(DecisionAgent.rbac_config.adapter).to eq(custom_adapter)
-      end
-    end
-
-    context "with no arguments" do
-      it "returns the rbac_config" do
-        result = DecisionAgent.configure_rbac
-        expect(result).to be_a(DecisionAgent::Auth::RbacConfig)
-      end
-    end
-  end
-
-  describe ".permission_checker" do
-    it "returns a PermissionChecker instance" do
-      checker = DecisionAgent.permission_checker
-      expect(checker).to be_a(DecisionAgent::Auth::PermissionChecker)
-    end
-
-    it "creates a new PermissionChecker if not set" do
-      # Reset permission_checker
-      DecisionAgent.permission_checker = nil
-      checker = DecisionAgent.permission_checker
-      expect(checker).to be_a(DecisionAgent::Auth::PermissionChecker)
-    end
-
-    it "returns the same instance on subsequent calls" do
-      checker1 = DecisionAgent.permission_checker
-      checker2 = DecisionAgent.permission_checker
-      expect(checker1).to eq(checker2)
-    end
-
-    it "uses the rbac_config adapter" do
-      DecisionAgent.configure_rbac(:default)
-      checker = DecisionAgent.permission_checker
-      adapter = checker.instance_variable_get(:@adapter)
-      expect(adapter).to be_a(DecisionAgent::Auth::RbacAdapter)
-      expect(DecisionAgent.rbac_config.adapter).to be_a(DecisionAgent::Auth::RbacAdapter)
-    end
-  end
-
-  describe ".permission_checker=" do
-    it "sets a custom permission checker" do
-      custom_checker = double("CustomChecker")
-      DecisionAgent.permission_checker = custom_checker
-      expect(DecisionAgent.permission_checker).to eq(custom_checker)
-    end
-
-    it "overrides the default permission checker" do
-      original_checker = DecisionAgent.permission_checker
-      custom_checker = double("CustomChecker")
-      DecisionAgent.permission_checker = custom_checker
-      expect(DecisionAgent.permission_checker).not_to eq(original_checker)
-      expect(DecisionAgent.permission_checker).to eq(custom_checker)
-    end
-  end
-end

data/spec/decision_spec.rb

@@ -1,423 +0,0 @@
-require "spec_helper"
-
-RSpec.describe DecisionAgent::Decision do
-  let(:evaluation) do
-    DecisionAgent::Evaluation.new(
-      decision: "approve",
-      weight: 0.8,
-      reason: "Test reason",
-      evaluator_name: "TestEvaluator"
-    )
-  end
-
-  let(:audit_payload) do
-    {
-      timestamp: "2025-01-01T00:00:00Z",
-      context: { user: "test" },
-      decision: "approve",
-      confidence: 0.8
-    }
-  end
-
-  describe "#initialize" do
-    it "creates a decision with all required fields" do
-      decision = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: ["Test explanation"],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      expect(decision.decision).to eq("approve")
-      expect(decision.confidence).to eq(0.8)
-      expect(decision.explanations).to eq(["Test explanation"])
-      expect(decision.evaluations).to eq([evaluation])
-      expect(decision.audit_payload).to eq(audit_payload)
-    end
-
-    it "converts decision to string" do
-      decision = described_class.new(
-        decision: :approve,
-        confidence: 0.8,
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      expect(decision.decision).to eq("approve")
-    end
-
-    it "converts confidence to float" do
-      decision = described_class.new(
-        decision: "approve",
-        confidence: "0.8",
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      expect(decision.confidence).to eq(0.8)
-    end
-
-    it "freezes the decision object" do
-      decision = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      expect(decision).to be_frozen
-    end
-
-    it "freezes nested structures" do
-      decision = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: ["explanation"],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      expect(decision.decision).to be_frozen
-      expect(decision.explanations).to be_frozen
-      expect(decision.explanations.first).to be_frozen
-      expect(decision.evaluations).to be_frozen
-    end
-
-    it "deep freezes audit payload" do
-      nested_payload = {
-        context: { user: { name: "test" } },
-        metadata: [1, 2, 3]
-      }
-
-      decision = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: nested_payload
-      )
-
-      expect(decision.audit_payload).to be_frozen
-      expect(decision.audit_payload[:context]).to be_frozen
-      expect(decision.audit_payload[:context][:user]).to be_frozen
-      expect(decision.audit_payload[:metadata]).to be_frozen
-    end
-
-    it "freezes audit payload in-place without creating new objects" do
-      original_payload = {
-        context: { user: "test" },
-        metadata: [1, 2, 3]
-      }
-      original_payload_id = original_payload.object_id
-      original_context_id = original_payload[:context].object_id
-
-      decision = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: original_payload
-      )
-
-      # Should freeze in-place, not create new objects
-      expect(decision.audit_payload.object_id).to eq(original_payload_id)
-      expect(decision.audit_payload[:context].object_id).to eq(original_context_id)
-      expect(decision.audit_payload).to be_frozen
-      expect(decision.audit_payload[:context]).to be_frozen
-    end
-
-    it "skips already frozen objects in deep_freeze" do
-      frozen_payload = {
-        context: { user: "test" }
-      }
-      frozen_payload.freeze
-      frozen_payload[:context].freeze
-
-      decision = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: frozen_payload
-      )
-
-      expect(decision.audit_payload).to be_frozen
-      expect(decision.audit_payload[:context]).to be_frozen
-    end
-
-    it "does not freeze hash keys unnecessarily" do
-      key_symbol = :test_key
-      key_string = "test_key"
-      payload = {
-        key_symbol => "value1",
-        key_string => "value2"
-      }
-
-      decision = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: payload
-      )
-
-      # Keys should not be frozen (they're typically symbols/strings that don't need freezing)
-      expect(decision.audit_payload.keys.first).to eq(key_symbol)
-      expect(decision.audit_payload.keys.last).to eq(key_string)
-      # Values should be frozen
-      expect(decision.audit_payload[key_symbol]).to be_frozen
-      expect(decision.audit_payload[key_string]).to be_frozen
-    end
-
-    it "raises error for confidence outside 0-1 range" do
-      expect do
-        described_class.new(
-          decision: "approve",
-          confidence: 1.5,
-          explanations: [],
-          evaluations: [evaluation],
-          audit_payload: audit_payload
-        )
-      end.to raise_error(DecisionAgent::InvalidConfidenceError)
-    end
-
-    it "raises error for negative confidence" do
-      expect do
-        described_class.new(
-          decision: "approve",
-          confidence: -0.1,
-          explanations: [],
-          evaluations: [evaluation],
-          audit_payload: audit_payload
-        )
-      end.to raise_error(DecisionAgent::InvalidConfidenceError)
-    end
-
-    it "accepts confidence at boundaries" do
-      decision1 = described_class.new(
-        decision: "approve",
-        confidence: 0.0,
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-      expect(decision1.confidence).to eq(0.0)
-
-      decision2 = described_class.new(
-        decision: "approve",
-        confidence: 1.0,
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-      expect(decision2.confidence).to eq(1.0)
-    end
-
-    it "handles array explanations" do
-      explanations = %w[explanation1 explanation2]
-      decision = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: explanations,
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      expect(decision.explanations).to eq(explanations)
-    end
-
-    it "converts non-array explanations to array" do
-      decision = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: "single explanation",
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      expect(decision.explanations).to eq(["single explanation"])
-    end
-  end
-
-  describe "#to_h" do
-    it "converts decision to hash" do
-      decision = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: ["explanation"],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      hash = decision.to_h
-
-      expect(hash).to be_a(Hash)
-      expect(hash[:decision]).to eq("approve")
-      expect(hash[:confidence]).to eq(0.8)
-      expect(hash[:explanations]).to eq(["explanation"])
-      expect(hash[:evaluations]).to be_an(Array)
-      expect(hash[:evaluations].first).to be_a(Hash)
-      expect(hash[:audit_payload]).to eq(audit_payload)
-    end
-
-    it "converts evaluations to hashes" do
-      decision = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      hash = decision.to_h
-      expect(hash[:evaluations].first[:decision]).to eq("approve")
-      expect(hash[:evaluations].first[:weight]).to eq(0.8)
-    end
-  end
-
-  describe "#==" do
-    it "compares decisions by all fields" do
-      decision1 = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: ["explanation"],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      decision2 = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: ["explanation"],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      expect(decision1).to eq(decision2)
-    end
-
-    it "returns false for different decisions" do
-      decision1 = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      decision2 = described_class.new(
-        decision: "reject",
-        confidence: 0.8,
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      expect(decision1).not_to eq(decision2)
-    end
-
-    it "returns false for different confidences" do
-      decision1 = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      decision2 = described_class.new(
-        decision: "approve",
-        confidence: 0.9,
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      expect(decision1).not_to eq(decision2)
-    end
-
-    it "allows small confidence differences" do
-      decision1 = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      decision2 = described_class.new(
-        decision: "approve",
-        confidence: 0.8000001,
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      expect(decision1).to eq(decision2)
-    end
-
-    it "returns false for different explanations" do
-      decision1 = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: ["explanation1"],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      decision2 = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: ["explanation2"],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      expect(decision1).not_to eq(decision2)
-    end
-
-    it "returns false for different evaluations" do
-      eval2 = DecisionAgent::Evaluation.new(
-        decision: "reject",
-        weight: 0.9,
-        reason: "Different reason",
-        evaluator_name: "OtherEvaluator"
-      )
-
-      decision1 = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      decision2 = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: [],
-        evaluations: [eval2],
-        audit_payload: audit_payload
-      )
-
-      expect(decision1).not_to eq(decision2)
-    end
-
-    it "returns false for non-Decision objects" do
-      decision = described_class.new(
-        decision: "approve",
-        confidence: 0.8,
-        explanations: [],
-        evaluations: [evaluation],
-        audit_payload: audit_payload
-      )
-
-      expect(decision).not_to eq("not a decision")
-      expect(decision).not_to eq(nil)
-    end
-  end
-end