decision_agent 0.2.0 → 0.3.0

data/spec/auth/rbac_adapter_spec.rb

@@ -547,4 +547,232 @@ RSpec.describe DecisionAgent::Auth::RbacAdapter do
       end
     end
   end
+
+  describe "Integration tests with real User and Role objects" do
+    let(:adapter) { DecisionAgent::Auth::DefaultAdapter.new }
+
+    describe "with real User and Role objects" do
+      it "checks permissions using real Role class" do
+        user = DecisionAgent::Auth::User.new(
+          id: "user1",
+          email: "admin@example.com",
+          password: "password123",
+          roles: [:admin]
+        )
+
+        expect(adapter.can?(user, :read)).to be true
+        expect(adapter.can?(user, :write)).to be true
+        expect(adapter.can?(user, :delete)).to be true
+        expect(adapter.can?(user, :manage_users)).to be true
+        expect(adapter.can?(user, :audit)).to be true
+      end
+
+      it "checks permissions for editor role" do
+        user = DecisionAgent::Auth::User.new(
+          id: "user2",
+          email: "editor@example.com",
+          password: "password123",
+          roles: [:editor]
+        )
+
+        expect(adapter.can?(user, :read)).to be true
+        expect(adapter.can?(user, :write)).to be true
+        expect(adapter.can?(user, :delete)).to be false
+        expect(adapter.can?(user, :manage_users)).to be false
+        expect(adapter.can?(user, :audit)).to be false
+      end
+
+      it "checks permissions for viewer role" do
+        user = DecisionAgent::Auth::User.new(
+          id: "user3",
+          email: "viewer@example.com",
+          password: "password123",
+          roles: [:viewer]
+        )
+
+        expect(adapter.can?(user, :read)).to be true
+        expect(adapter.can?(user, :write)).to be false
+        expect(adapter.can?(user, :delete)).to be false
+        expect(adapter.can?(user, :manage_users)).to be false
+      end
+
+      it "checks permissions for approver role" do
+        user = DecisionAgent::Auth::User.new(
+          id: "user4",
+          email: "approver@example.com",
+          password: "password123",
+          roles: [:approver]
+        )
+
+        expect(adapter.can?(user, :read)).to be true
+        expect(adapter.can?(user, :approve)).to be true
+        expect(adapter.can?(user, :write)).to be false
+        expect(adapter.can?(user, :delete)).to be false
+      end
+
+      it "checks permissions for auditor role" do
+        user = DecisionAgent::Auth::User.new(
+          id: "user5",
+          email: "auditor@example.com",
+          password: "password123",
+          roles: [:auditor]
+        )
+
+        expect(adapter.can?(user, :read)).to be true
+        expect(adapter.can?(user, :audit)).to be true
+        expect(adapter.can?(user, :write)).to be false
+        expect(adapter.can?(user, :delete)).to be false
+      end
+
+      it "checks permissions for user with multiple roles" do
+        user = DecisionAgent::Auth::User.new(
+          id: "user6",
+          email: "multi@example.com",
+          password: "password123",
+          roles: %i[viewer editor]
+        )
+
+        # Should have permissions from both roles
+        expect(adapter.can?(user, :read)).to be true  # from viewer
+        expect(adapter.can?(user, :write)).to be true # from editor
+        expect(adapter.can?(user, :delete)).to be false
+      end
+
+      it "checks role membership using real Role class" do
+        admin_user = DecisionAgent::Auth::User.new(
+          id: "admin1",
+          email: "admin@example.com",
+          password: "password123",
+          roles: [:admin]
+        )
+
+        expect(adapter.has_role?(admin_user, :admin)).to be true
+        expect(adapter.has_role?(admin_user, :editor)).to be false
+        expect(adapter.has_role?(admin_user, :viewer)).to be false
+
+        editor_user = DecisionAgent::Auth::User.new(
+          id: "editor1",
+          email: "editor@example.com",
+          password: "password123",
+          roles: [:editor]
+        )
+
+        expect(adapter.has_role?(editor_user, :editor)).to be true
+        expect(adapter.has_role?(editor_user, :admin)).to be false
+      end
+
+      it "checks role membership for users with multiple roles" do
+        user = DecisionAgent::Auth::User.new(
+          id: "multi1",
+          email: "multi@example.com",
+          password: "password123",
+          roles: %i[admin editor]
+        )
+
+        expect(adapter.has_role?(user, :admin)).to be true
+        expect(adapter.has_role?(user, :editor)).to be true
+        expect(adapter.has_role?(user, :viewer)).to be false
+      end
+
+      it "handles dynamic role assignment" do
+        user = DecisionAgent::Auth::User.new(
+          id: "dynamic1",
+          email: "dynamic@example.com",
+          password: "password123",
+          roles: []
+        )
+
+        expect(adapter.has_role?(user, :admin)).to be false
+        expect(adapter.can?(user, :read)).to be false
+
+        # Assign role dynamically
+        user.assign_role(:viewer)
+
+        expect(adapter.has_role?(user, :viewer)).to be true
+        expect(adapter.can?(user, :read)).to be true
+        expect(adapter.can?(user, :write)).to be false
+      end
+
+      it "handles role removal" do
+        user = DecisionAgent::Auth::User.new(
+          id: "remove1",
+          email: "remove@example.com",
+          password: "password123",
+          roles: %i[admin editor]
+        )
+
+        expect(adapter.has_role?(user, :admin)).to be true
+        expect(adapter.can?(user, :manage_users)).to be true
+
+        # Remove admin role
+        user.remove_role(:admin)
+
+        expect(adapter.has_role?(user, :admin)).to be false
+        expect(adapter.has_role?(user, :editor)).to be true
+        expect(adapter.can?(user, :manage_users)).to be false
+        expect(adapter.can?(user, :write)).to be true # Still has editor role
+      end
+
+      it "checks active status with real User objects" do
+        active_user = DecisionAgent::Auth::User.new(
+          id: "active1",
+          email: "active@example.com",
+          password: "password123",
+          roles: [:admin],
+          active: true
+        )
+
+        expect(adapter.active?(active_user)).to be true
+        expect(adapter.can?(active_user, :read)).to be true
+
+        inactive_user = DecisionAgent::Auth::User.new(
+          id: "inactive1",
+          email: "inactive@example.com",
+          password: "password123",
+          roles: [:admin],
+          active: false
+        )
+
+        expect(adapter.active?(inactive_user)).to be false
+        expect(adapter.can?(inactive_user, :read)).to be false # Inactive users can't do anything
+      end
+
+      it "gets user ID and email from real User objects" do
+        user = DecisionAgent::Auth::User.new(
+          id: "userid123",
+          email: "real@example.com",
+          password: "password123",
+          roles: [:admin]
+        )
+
+        expect(adapter.user_id(user)).to eq("userid123")
+        expect(adapter.user_email(user)).to eq("real@example.com")
+      end
+
+      it "verifies permission checking integrates with real Role.has_permission? method" do
+        # Test that the adapter correctly uses Role.has_permission? for all defined roles
+        roles_to_test = DecisionAgent::Auth::Role.all
+
+        roles_to_test.each do |role|
+          user = DecisionAgent::Auth::User.new(
+            id: "role_test_#{role}",
+            email: "#{role}@example.com",
+            password: "password123",
+            roles: [role]
+          )
+
+          # Get expected permissions from Role class
+          expected_permissions = DecisionAgent::Auth::Role.permissions_for(role)
+
+          # Verify adapter returns same permissions
+          all_permissions = %i[read write delete approve deploy manage_users audit]
+          all_permissions.each do |permission|
+            expected = expected_permissions.include?(permission)
+            actual = adapter.can?(user, permission)
+            expect(actual).to eq(expected), "Role #{role} permission #{permission} mismatch: expected #{expected}, got #{actual}"
+          end
+        end
+      end
+    end
+  end
 end

data/spec/dmn/decision_graph_spec.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "decision_agent/dmn/decision_graph"
+
+RSpec.describe DecisionAgent::Dmn::DecisionGraph do
+  describe "graph construction" do
+    let(:graph) do
+      described_class.new(id: "graph1", name: "Test Graph")
+    end
+
+    it "creates an empty graph" do
+      expect(graph.decisions).to be_empty
+    end
+
+    it "adds decisions to the graph" do
+      decision = DecisionAgent::Dmn::DecisionNode.new(
+        id: "decision1",
+        name: "First Decision"
+      )
+      graph.add_decision(decision)
+
+      expect(graph.decisions["decision1"]).to eq(decision)
+    end
+
+    it "retrieves decisions by id" do
+      decision = DecisionAgent::Dmn::DecisionNode.new(id: "decision1", name: "Test")
+      graph.add_decision(decision)
+
+      retrieved = graph.get_decision("decision1")
+      expect(retrieved).to eq(decision)
+    end
+  end
+
+  describe "decision dependencies" do
+    let(:graph) do
+      graph = described_class.new(id: "dep_graph", name: "Dependency Graph")
+
+      # Create decisions
+      decision1 = DecisionAgent::Dmn::DecisionNode.new(
+        id: "base_rate",
+        name: "Base Rate",
+        decision_logic: 0.05
+      )
+
+      decision2 = DecisionAgent::Dmn::DecisionNode.new(
+        id: "risk_adjustment",
+        name: "Risk Adjustment",
+        decision_logic: 0.02
+      )
+
+      decision3 = DecisionAgent::Dmn::DecisionNode.new(
+        id: "final_rate",
+        name: "Final Rate",
+        decision_logic: ->(context) { context["base_rate"] + context["risk_adjustment"] }
+      )
+
+      # Add dependencies
+      decision3.add_dependency("base_rate")
+      decision3.add_dependency("risk_adjustment")
+
+      graph.add_decision(decision1)
+      graph.add_decision(decision2)
+      graph.add_decision(decision3)
+
+      graph
+    end
+
+    it "tracks decision dependencies" do
+      decision = graph.get_decision("final_rate")
+      expect(decision.information_requirements.length).to eq(2)
+      expect(decision.depends_on?("base_rate")).to be true
+      expect(decision.depends_on?("risk_adjustment")).to be true
+    end
+
+    it "evaluates decision with dependencies" do
+      result = graph.evaluate("final_rate", {})
+      expect(result).to eq(0.07) # 0.05 + 0.02
+    end
+  end
+
+  describe "topological ordering" do
+    let(:graph) do
+      graph = described_class.new(id: "topo_graph", name: "Topological Graph")
+
+      # Create a dependency chain: A -> B -> C
+      decision_a = DecisionAgent::Dmn::DecisionNode.new(id: "a", name: "A", decision_logic: 1)
+      decision_b = DecisionAgent::Dmn::DecisionNode.new(id: "b", name: "B", decision_logic: ->(ctx) { ctx["a"] + 1 })
+      decision_c = DecisionAgent::Dmn::DecisionNode.new(id: "c", name: "C", decision_logic: ->(ctx) { ctx["b"] + 1 })
+
+      decision_b.add_dependency("a")
+      decision_c.add_dependency("b")
+
+      graph.add_decision(decision_a)
+      graph.add_decision(decision_b)
+      graph.add_decision(decision_c)
+
+      graph
+    end
+
+    it "returns decisions in topological order" do
+      order = graph.topological_order
+      expect(order.index("a")).to be < order.index("b")
+      expect(order.index("b")).to be < order.index("c")
+    end
+
+    it "identifies root decisions" do
+      roots = graph.root_decisions
+      expect(roots).to eq(["a"])
+    end
+
+    it "identifies leaf decisions" do
+      leaves = graph.leaf_decisions
+      expect(leaves).to eq(["c"])
+    end
+  end
+
+  describe "circular dependency detection" do
+    it "detects circular dependencies" do
+      graph = described_class.new(id: "circular", name: "Circular Graph")
+
+      decision_a = DecisionAgent::Dmn::DecisionNode.new(id: "a", name: "A")
+      decision_b = DecisionAgent::Dmn::DecisionNode.new(id: "b", name: "B")
+
+      decision_a.add_dependency("b")
+      decision_b.add_dependency("a")
+
+      graph.add_decision(decision_a)
+      graph.add_decision(decision_b)
+
+      expect(graph.circular_dependencies?).to be true
+    end
+
+    it "raises error when evaluating circular dependencies" do
+      graph = described_class.new(id: "circular", name: "Circular Graph")
+
+      decision_a = DecisionAgent::Dmn::DecisionNode.new(id: "a", name: "A")
+      decision_b = DecisionAgent::Dmn::DecisionNode.new(id: "b", name: "B")
+
+      decision_a.add_dependency("b")
+      decision_b.add_dependency("a")
+
+      graph.add_decision(decision_a)
+      graph.add_decision(decision_b)
+
+      expect { graph.topological_order }.to raise_error(DecisionAgent::Dmn::DmnError, /Circular dependency/)
+    end
+  end
+
+  describe "complex graph evaluation" do
+    let(:graph) do
+      # Build a loan approval graph
+      # Decisions: income_check -> credit_check -> final_decision
+      graph = described_class.new(id: "loan_graph", name: "Loan Approval Graph")
+
+      income_check = DecisionAgent::Dmn::DecisionNode.new(
+        id: "income_check",
+        name: "Income Check",
+        decision_logic: ->(ctx) { ctx["income"] >= 50_000 ? "sufficient" : "insufficient" }
+      )
+
+      credit_check = DecisionAgent::Dmn::DecisionNode.new(
+        id: "credit_check",
+        name: "Credit Check",
+        decision_logic: ->(ctx) { ctx["credit_score"] >= 650 ? "good" : "poor" }
+      )
+
+      final_decision = DecisionAgent::Dmn::DecisionNode.new(
+        id: "final_decision",
+        name: "Final Decision",
+        decision_logic: lambda do |ctx|
+          if ctx["income_check"] == "sufficient" && ctx["credit_check"] == "good"
+            "Approved"
+          else
+            "Rejected"
+          end
+        end
+      )
+
+      final_decision.add_dependency("income_check", "income_check")
+      final_decision.add_dependency("credit_check", "credit_check")
+
+      graph.add_decision(income_check)
+      graph.add_decision(credit_check)
+      graph.add_decision(final_decision)
+
+      graph
+    end
+
+    it "evaluates graph with all dependencies for approved case" do
+      context = { income: 60_000, credit_score: 700 }
+      result = graph.evaluate("final_decision", context)
+      expect(result).to eq("Approved")
+    end
+
+    it "evaluates graph with all dependencies for rejected case" do
+      context = { income: 40_000, credit_score: 600 }
+      result = graph.evaluate("final_decision", context)
+      expect(result).to eq("Rejected")
+    end
+
+    it "evaluates all decisions in graph" do
+      context = { income: 60_000, credit_score: 700 }
+      results = graph.evaluate_all(context)
+
+      expect(results["income_check"]).to eq("sufficient")
+      expect(results["credit_check"]).to eq("good")
+      expect(results["final_decision"]).to eq("Approved")
+    end
+  end
+
+  describe "graph analysis" do
+    let(:graph) do
+      graph = described_class.new(id: "analysis", name: "Analysis Graph")
+
+      d1 = DecisionAgent::Dmn::DecisionNode.new(id: "d1", name: "D1", decision_logic: 1)
+      d2 = DecisionAgent::Dmn::DecisionNode.new(id: "d2", name: "D2", decision_logic: 2)
+      d3 = DecisionAgent::Dmn::DecisionNode.new(id: "d3", name: "D3", decision_logic: 3)
+
+      d3.add_dependency("d1")
+      d3.add_dependency("d2")
+
+      graph.add_decision(d1)
+      graph.add_decision(d2)
+      graph.add_decision(d3)
+
+      graph
+    end
+
+    it "exports dependency graph structure" do
+      dep_graph = graph.dependency_graph
+      expect(dep_graph["d1"]).to eq([])
+      expect(dep_graph["d2"]).to eq([])
+      expect(dep_graph["d3"]).to contain_exactly("d1", "d2")
+    end
+
+    it "exports graph to hash representation" do
+      hash = graph.to_h
+      expect(hash[:id]).to eq("analysis")
+      expect(hash[:name]).to eq("Analysis Graph")
+      expect(hash[:decisions].keys).to contain_exactly("d1", "d2", "d3")
+      expect(hash[:dependency_graph]).to be_a(Hash)
+    end
+  end
+
+  describe DecisionAgent::Dmn::DecisionNode do
+    it "creates decision node with basic attributes" do
+      node = described_class.new(id: "test", name: "Test Decision")
+      expect(node.id).to eq("test")
+      expect(node.name).to eq("Test Decision")
+      expect(node.information_requirements).to be_empty
+    end
+
+    it "adds dependencies" do
+      node = described_class.new(id: "test", name: "Test")
+      node.add_dependency("dep1", "variable1")
+
+      expect(node.information_requirements.length).to eq(1)
+      expect(node.information_requirements.first[:decision_id]).to eq("dep1")
+      expect(node.information_requirements.first[:variable_name]).to eq("variable1")
+    end
+
+    it "checks if node depends on another decision" do
+      node = described_class.new(id: "test", name: "Test")
+      node.add_dependency("dep1")
+
+      expect(node.depends_on?("dep1")).to be true
+      expect(node.depends_on?("dep2")).to be false
+    end
+
+    it "resets evaluation state" do
+      node = described_class.new(id: "test", name: "Test")
+      node.value = "some value"
+      node.evaluated = true
+
+      node.reset!
+
+      expect(node.value).to be_nil
+      expect(node.evaluated).to be false
+    end
+  end
+end