decision_agent 0.1.4 → 0.1.7

data/lib/decision_agent.rb

@@ -43,5 +43,57 @@ require_relative "decision_agent/ab_testing/ab_testing_agent"
 require_relative "decision_agent/ab_testing/storage/adapter"
 require_relative "decision_agent/ab_testing/storage/memory_adapter"
 
+require_relative "decision_agent/testing/test_scenario"
+require_relative "decision_agent/testing/batch_test_importer"
+require_relative "decision_agent/testing/batch_test_runner"
+require_relative "decision_agent/testing/test_result_comparator"
+require_relative "decision_agent/testing/test_coverage_analyzer"
+
+require_relative "decision_agent/auth/user"
+require_relative "decision_agent/auth/role"
+require_relative "decision_agent/auth/permission"
+require_relative "decision_agent/auth/session"
+require_relative "decision_agent/auth/session_manager"
+require_relative "decision_agent/auth/password_reset_token"
+require_relative "decision_agent/auth/password_reset_manager"
+require_relative "decision_agent/auth/authenticator"
+require_relative "decision_agent/auth/rbac_adapter"
+require_relative "decision_agent/auth/rbac_config"
+require_relative "decision_agent/auth/permission_checker"
+require_relative "decision_agent/auth/access_audit_logger"
+
 module DecisionAgent
+  # Global RBAC configuration
+  @rbac_config = Auth::RbacConfig.new
+
+  class << self
+    attr_reader :rbac_config
+
+    # Configure RBAC adapter
+    # @param adapter_type [Symbol] :default, :devise_cancan, :pundit, or :custom
+    # @param options [Hash] Options for the adapter
+    # @yield [RbacConfig] Configuration block
+    # @example
+    #   DecisionAgent.configure_rbac(:devise_cancan, ability_class: Ability)
+    # @example
+    #   DecisionAgent.configure_rbac(:custom) do |config|
+    #     config.adapter = MyCustomAdapter.new
+    #   end
+    def configure_rbac(adapter_type = nil, **options)
+      if block_given?
+        yield @rbac_config
+      elsif adapter_type
+        @rbac_config.use(adapter_type, **options)
+      end
+      @rbac_config
+    end
+
+    # Get the configured permission checker
+    def permission_checker
+      @permission_checker ||= Auth::PermissionChecker.new(adapter: @rbac_config.adapter)
+    end
+
+    # Set a custom permission checker
+    attr_writer :permission_checker
+  end
 end

data/lib/generators/decision_agent/install/templates/README

@@ -42,6 +42,6 @@ Next steps:
    # mount DecisionAgent::Engine => '/decision_agent'
 
 For more information, visit:
-https://github.com/samaswin87/decision_agent
+https://github.com/samaswin/decision_agent
 
 ===============================================================================

data/lib/generators/decision_agent/install/templates/rule_version.rb

@@ -33,7 +33,7 @@ class RuleVersion < ApplicationRecord
       self.class.where(rule_id: rule_id, status: "active")
           .where.not(id: id)
           .find_each do |v|
-        v.update!(status: "archived")
+            v.update!(status: "archived")
       end
 
       # Activate this version

data/spec/ab_testing/ab_test_assignment_spec.rb

@@ -0,0 +1,253 @@
+require "spec_helper"
+require "decision_agent/ab_testing/ab_test_assignment"
+
+RSpec.describe DecisionAgent::ABTesting::ABTestAssignment do
+  describe "#initialize" do
+    it "creates an assignment with required fields" do
+      assignment = described_class.new(
+        ab_test_id: "test_1",
+        variant: :champion,
+        version_id: "v1"
+      )
+
+      expect(assignment.ab_test_id).to eq("test_1")
+      expect(assignment.variant).to eq(:champion)
+      expect(assignment.version_id).to eq("v1")
+      expect(assignment.timestamp).to be_a(Time)
+    end
+
+    it "accepts optional user_id" do
+      assignment = described_class.new(
+        ab_test_id: "test_1",
+        variant: :champion,
+        version_id: "v1",
+        user_id: "user_123"
+      )
+
+      expect(assignment.user_id).to eq("user_123")
+    end
+
+    it "accepts optional timestamp" do
+      custom_time = Time.new(2024, 1, 1, 12, 0, 0, "+00:00")
+      assignment = described_class.new(
+        ab_test_id: "test_1",
+        variant: :champion,
+        version_id: "v1",
+        timestamp: custom_time
+      )
+
+      expect(assignment.timestamp).to eq(custom_time)
+    end
+
+    it "accepts optional decision_result and confidence" do
+      assignment = described_class.new(
+        ab_test_id: "test_1",
+        variant: :champion,
+        version_id: "v1",
+        decision_result: "approve",
+        confidence: 0.95
+      )
+
+      expect(assignment.decision_result).to eq("approve")
+      expect(assignment.confidence).to eq(0.95)
+    end
+
+    it "accepts optional context" do
+      context = { user_type: "premium", region: "us" }
+      assignment = described_class.new(
+        ab_test_id: "test_1",
+        variant: :champion,
+        version_id: "v1",
+        context: context
+      )
+
+      expect(assignment.context).to eq(context)
+    end
+
+    it "defaults context to empty hash" do
+      assignment = described_class.new(
+        ab_test_id: "test_1",
+        variant: :champion,
+        version_id: "v1"
+      )
+
+      expect(assignment.context).to eq({})
+    end
+
+    it "accepts optional id" do
+      assignment = described_class.new(
+        ab_test_id: "test_1",
+        variant: :champion,
+        version_id: "v1",
+        id: "assign_123"
+      )
+
+      expect(assignment.id).to eq("assign_123")
+    end
+
+    it "raises error if ab_test_id is nil" do
+      expect do
+        described_class.new(
+          ab_test_id: nil,
+          variant: :champion,
+          version_id: "v1"
+        )
+      end.to raise_error(DecisionAgent::ValidationError, /AB test ID is required/)
+    end
+
+    it "raises error if variant is nil" do
+      expect do
+        described_class.new(
+          ab_test_id: "test_1",
+          variant: nil,
+          version_id: "v1"
+        )
+      end.to raise_error(DecisionAgent::ValidationError, /Variant is required/)
+    end
+
+    it "raises error if version_id is nil" do
+      expect do
+        described_class.new(
+          ab_test_id: "test_1",
+          variant: :champion,
+          version_id: nil
+        )
+      end.to raise_error(DecisionAgent::ValidationError, /Version ID is required/)
+    end
+
+    it "raises error if variant is not :champion or :challenger" do
+      expect do
+        described_class.new(
+          ab_test_id: "test_1",
+          variant: :invalid,
+          version_id: "v1"
+        )
+      end.to raise_error(DecisionAgent::ValidationError, /Variant must be :champion or :challenger/)
+    end
+
+    it "raises error if confidence is negative" do
+      expect do
+        described_class.new(
+          ab_test_id: "test_1",
+          variant: :champion,
+          version_id: "v1",
+          confidence: -0.1
+        )
+      end.to raise_error(DecisionAgent::ValidationError, /Confidence must be between 0 and 1/)
+    end
+
+    it "raises error if confidence is greater than 1" do
+      expect do
+        described_class.new(
+          ab_test_id: "test_1",
+          variant: :champion,
+          version_id: "v1",
+          confidence: 1.5
+        )
+      end.to raise_error(DecisionAgent::ValidationError, /Confidence must be between 0 and 1/)
+    end
+
+    it "accepts confidence of 0" do
+      assignment = described_class.new(
+        ab_test_id: "test_1",
+        variant: :champion,
+        version_id: "v1",
+        confidence: 0.0
+      )
+
+      expect(assignment.confidence).to eq(0.0)
+    end
+
+    it "accepts confidence of 1" do
+      assignment = described_class.new(
+        ab_test_id: "test_1",
+        variant: :champion,
+        version_id: "v1",
+        confidence: 1.0
+      )
+
+      expect(assignment.confidence).to eq(1.0)
+    end
+
+    it "accepts challenger variant" do
+      assignment = described_class.new(
+        ab_test_id: "test_1",
+        variant: :challenger,
+        version_id: "v2"
+      )
+
+      expect(assignment.variant).to eq(:challenger)
+    end
+  end
+
+  describe "#record_decision" do
+    let(:assignment) do
+      described_class.new(
+        ab_test_id: "test_1",
+        variant: :champion,
+        version_id: "v1"
+      )
+    end
+
+    it "updates decision_result and confidence" do
+      assignment.record_decision("approve", 0.95)
+
+      expect(assignment.decision_result).to eq("approve")
+      expect(assignment.confidence).to eq(0.95)
+    end
+
+    it "can update multiple times" do
+      assignment.record_decision("approve", 0.95)
+      assignment.record_decision("reject", 0.85)
+
+      expect(assignment.decision_result).to eq("reject")
+      expect(assignment.confidence).to eq(0.85)
+    end
+  end
+
+  describe "#to_h" do
+    it "converts assignment to hash with all fields" do
+      assignment = described_class.new(
+        ab_test_id: "test_1",
+        variant: :champion,
+        version_id: "v1",
+        id: "assign_123",
+        user_id: "user_456",
+        decision_result: "approve",
+        confidence: 0.95,
+        context: { region: "us" },
+        timestamp: Time.new(2024, 1, 1, 12, 0, 0, "+00:00")
+      )
+
+      hash = assignment.to_h
+
+      expect(hash).to eq({
+                           id: "assign_123",
+                           ab_test_id: "test_1",
+                           user_id: "user_456",
+                           variant: :champion,
+                           version_id: "v1",
+                           timestamp: Time.new(2024, 1, 1, 12, 0, 0, "+00:00"),
+                           decision_result: "approve",
+                           confidence: 0.95,
+                           context: { region: "us" }
+                         })
+    end
+
+    it "includes nil values in hash" do
+      assignment = described_class.new(
+        ab_test_id: "test_1",
+        variant: :champion,
+        version_id: "v1"
+      )
+
+      hash = assignment.to_h
+
+      expect(hash[:id]).to be_nil
+      expect(hash[:user_id]).to be_nil
+      expect(hash[:decision_result]).to be_nil
+      expect(hash[:confidence]).to be_nil
+      expect(hash[:context]).to eq({})
+    end
+  end
+end

data/spec/ab_testing/ab_test_manager_spec.rb

@@ -75,6 +75,32 @@ RSpec.describe DecisionAgent::ABTesting::ABTestManager do
 
       expect(test.traffic_split).to eq({ champion: 70, challenger: 30 })
     end
+
+    it "accepts start_date and end_date" do
+      start_date = Time.now.utc + 3600
+      end_date = Time.now.utc + 7200
+      test = manager.create_test(
+        name: "Scheduled Test",
+        champion_version_id: @champion[:id],
+        challenger_version_id: @challenger[:id],
+        start_date: start_date,
+        end_date: end_date
+      )
+
+      expect(test.start_date).to eq(start_date)
+      expect(test.end_date).to eq(end_date)
+    end
+
+    it "sets status to running if start_date is in the past" do
+      test = manager.create_test(
+        name: "Immediate Test",
+        champion_version_id: @champion[:id],
+        challenger_version_id: @challenger[:id],
+        start_date: Time.now.utc - 3600
+      )
+
+      expect(test.status).to eq("running")
+    end
   end
 
   describe "#get_test" do
@@ -326,5 +352,261 @@ RSpec.describe DecisionAgent::ABTesting::ABTestManager do
 
       expect(results[:comparison][:statistical_significance]).to eq("not_significant")
     end
+
+    it "handles tests with assignments but no decisions" do
+      # Create assignments without recording decisions
+      10.times do |i|
+        manager.assign_variant(test_id: test.id, user_id: "user_#{i}")
+      end
+
+      results = manager.get_results(test.id)
+
+      expect(results[:champion][:decisions_recorded]).to eq(0)
+      expect(results[:challenger][:decisions_recorded]).to eq(0)
+      expect(results[:comparison][:statistical_significance]).to eq("insufficient_data")
+    end
+
+    it "calculates statistical significance with sufficient data" do
+      # Create 30+ assignments for each variant to trigger statistical significance
+      champion_count = 0
+      challenger_count = 0
+
+      100.times do |i|
+        assignment = manager.assign_variant(test_id: test.id, user_id: "user_#{i}")
+        if assignment[:variant] == :champion
+          champion_count += 1
+          confidence = 0.7
+        else
+          challenger_count += 1
+          confidence = 0.9
+        end
+
+        manager.record_decision(
+          assignment_id: assignment[:assignment_id],
+          decision: "approve",
+          confidence: confidence
+        )
+      end
+
+      results = manager.get_results(test.id)
+
+      # Should have enough data for statistical significance
+      expect(results[:champion][:decisions_recorded]).to be >= 30
+      expect(results[:challenger][:decisions_recorded]).to be >= 30
+      expect(%w[significant not_significant]).to include(results[:comparison][:statistical_significance])
+    end
+
+    it "calculates different confidence levels based on t-statistic" do
+      # Create data that will result in different t-statistic values
+      # High t-statistic (> 2.576) should give 99% confidence
+      50.times do |i|
+        assignment = manager.assign_variant(test_id: test.id, user_id: "user_#{i}")
+        # Large difference to get high t-statistic
+        confidence = assignment[:variant] == :champion ? 0.5 : 0.95
+        manager.record_decision(
+          assignment_id: assignment[:assignment_id],
+          decision: "approve",
+          confidence: confidence
+        )
+      end
+
+      results = manager.get_results(test.id)
+      expect(results[:comparison][:confidence_level]).to be_a(Numeric)
+      expect(results[:comparison][:confidence_level]).to be >= 0.0
+    end
+
+    it "determines winner correctly when challenger is better" do
+      50.times do |i|
+        assignment = manager.assign_variant(test_id: test.id, user_id: "user_#{i}")
+        confidence = assignment[:variant] == :champion ? 0.6 : 0.9
+        manager.record_decision(
+          assignment_id: assignment[:assignment_id],
+          decision: "approve",
+          confidence: confidence
+        )
+      end
+
+      results = manager.get_results(test.id)
+      expect(%w[champion challenger inconclusive]).to include(results[:comparison][:winner])
+    end
+
+    it "generates appropriate recommendations" do
+      # Test different improvement scenarios
+      50.times do |i|
+        assignment = manager.assign_variant(test_id: test.id, user_id: "user_#{i}")
+        # Challenger significantly better (>5% improvement)
+        confidence = assignment[:variant] == :champion ? 0.7 : 0.8
+        manager.record_decision(
+          assignment_id: assignment[:assignment_id],
+          decision: "approve",
+          confidence: confidence
+        )
+      end
+
+      results = manager.get_results(test.id)
+      expect(results[:comparison][:recommendation]).to be_a(String)
+      expect(results[:comparison][:recommendation]).not_to be_empty
+    end
+
+    it "handles champion better than challenger scenario" do
+      50.times do |i|
+        assignment = manager.assign_variant(test_id: test.id, user_id: "user_#{i}")
+        # Champion better
+        confidence = assignment[:variant] == :champion ? 0.9 : 0.7
+        manager.record_decision(
+          assignment_id: assignment[:assignment_id],
+          decision: "approve",
+          confidence: confidence
+        )
+      end
+
+      results = manager.get_results(test.id)
+      expect(results[:comparison][:improvement_percentage]).to be < 0
+    end
+
+    it "handles similar performance scenario" do
+      50.times do |i|
+        assignment = manager.assign_variant(test_id: test.id, user_id: "user_#{i}")
+        # Similar performance
+        confidence = assignment[:variant] == :champion ? 0.75 : 0.76
+        manager.record_decision(
+          assignment_id: assignment[:assignment_id],
+          decision: "approve",
+          confidence: confidence
+        )
+      end
+
+      results = manager.get_results(test.id)
+      expect(results[:comparison][:improvement_percentage]).to be_between(-5, 5)
+    end
+  end
+
+  describe "#list_tests" do
+    before do
+      manager.create_test(
+        name: "Test 1",
+        champion_version_id: @champion[:id],
+        challenger_version_id: @challenger[:id]
+      )
+      manager.create_test(
+        name: "Test 2",
+        champion_version_id: @champion[:id],
+        challenger_version_id: @challenger[:id]
+      )
+    end
+
+    it "lists all tests when no filters" do
+      tests = manager.list_tests
+      expect(tests.size).to be >= 2
+    end
+
+    it "filters by status" do
+      tests = manager.list_tests(status: "scheduled")
+      expect(tests).to all(have_attributes(status: "scheduled"))
+    end
+
+    it "respects limit parameter" do
+      tests = manager.list_tests(limit: 1)
+      expect(tests.size).to eq(1)
+    end
+  end
+
+  describe "#initialize" do
+    it "uses default storage adapter when not provided" do
+      manager = described_class.new(version_manager: version_manager)
+      expect(manager.storage_adapter).to be_a(DecisionAgent::ABTesting::Storage::MemoryAdapter)
+    end
+
+    it "uses default version manager when not provided" do
+      manager = described_class.new
+      expect(manager.version_manager).to be_a(DecisionAgent::Versioning::VersionManager)
+    end
+  end
+
+  describe "cache behavior" do
+    let(:test) do
+      manager.create_test(
+        name: "Test",
+        champion_version_id: @champion[:id],
+        challenger_version_id: @challenger[:id],
+        start_date: Time.now.utc + 3600
+      )
+    end
+
+    it "invalidates cache when test is started" do
+      manager.active_tests # Populate cache
+      manager.start_test(test.id)
+      # Cache should be invalidated, so next call should hit storage
+      expect(storage_adapter).to receive(:list_tests).and_call_original
+      manager.active_tests
+    end
+
+    it "invalidates cache when test is completed" do
+      manager.active_tests # Populate cache
+      manager.start_test(test.id) # Start the test first so it can be completed
+      manager.complete_test(test.id)
+      expect(storage_adapter).to receive(:list_tests).and_call_original
+      manager.active_tests
+    end
+
+    it "invalidates cache when test is cancelled" do
+      manager.active_tests # Populate cache
+      manager.cancel_test(test.id)
+      expect(storage_adapter).to receive(:list_tests).and_call_original
+      manager.active_tests
+    end
+
+    it "cache expires after 60 seconds" do
+      manager.active_tests # Populate cache
+      # Simulate time passing
+      allow(Time).to receive(:now).and_return(Time.now.utc + 61)
+      expect(storage_adapter).to receive(:list_tests).and_call_original
+      manager.active_tests
+    end
+  end
+
+  describe "#get_results edge cases" do
+    let(:test) do
+      test = manager.create_test(
+        name: "Test",
+        champion_version_id: @champion[:id],
+        challenger_version_id: @challenger[:id],
+        start_date: Time.now.utc + 3600
+      )
+      manager.start_test(test.id)
+      test
+    end
+
+    it "handles assignments with different decision results" do
+      20.times do |i|
+        assignment = manager.assign_variant(test_id: test.id, user_id: "user_#{i}")
+        decision = i.even? ? "approve" : "reject"
+        manager.record_decision(
+          assignment_id: assignment[:assignment_id],
+          decision: decision,
+          confidence: 0.8
+        )
+      end
+
+      results = manager.get_results(test.id)
+      expect(results[:champion][:decision_distribution]).to be_a(Hash)
+      expect(results[:challenger][:decision_distribution]).to be_a(Hash)
+    end
+
+    it "calculates min and max confidence correctly" do
+      20.times do |i|
+        assignment = manager.assign_variant(test_id: test.id, user_id: "user_#{i}")
+        confidence = 0.5 + (i * 0.02) # Range from 0.5 to 0.88
+        manager.record_decision(
+          assignment_id: assignment[:assignment_id],
+          decision: "approve",
+          confidence: confidence
+        )
+      end
+
+      results = manager.get_results(test.id)
+      expect(results[:champion][:min_confidence]).to be_a(Numeric).or be_nil
+      expect(results[:champion][:max_confidence]).to be_a(Numeric).or be_nil
+    end
   end
 end