decision_agent 0.1.2 → 0.1.3

data/spec/activerecord_thread_safety_spec.rb

@@ -0,0 +1,553 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Only run these tests if ActiveRecord is available
+if defined?(ActiveRecord)
+  RSpec.describe "ActiveRecordAdapter Thread-Safety" do
+    # Setup in-memory SQLite database for testing
+    before(:all) do
+      ActiveRecord::Base.establish_connection(
+        adapter: "sqlite3",
+        database: "file::memory:?cache=shared",
+        timeout: 10_000,
+        pool: 110 # Support 100 thread test + some overhead
+      )
+
+      # Enable WAL mode and busy timeout for better concurrency
+      ActiveRecord::Base.connection.execute("PRAGMA journal_mode=WAL")
+      ActiveRecord::Base.connection.execute("PRAGMA busy_timeout=10000")
+
+      # Create the schema
+      ActiveRecord::Schema.define do
+        create_table :rule_versions, force: true do |t|
+          t.string :rule_id, null: false
+          t.integer :version_number, null: false
+          t.text :content, null: false
+          t.string :created_by, null: false, default: "system"
+          t.text :changelog
+          t.string :status, null: false, default: "draft"
+          t.timestamps
+        end
+
+        add_index :rule_versions, %i[rule_id version_number], unique: true
+        add_index :rule_versions, %i[rule_id status]
+      end
+
+      # Define RuleVersion model if not already defined
+      unless defined?(RuleVersion)
+        class ::RuleVersion < ActiveRecord::Base
+          validates :rule_id, presence: true
+          validates :version_number, presence: true, uniqueness: { scope: :rule_id }
+          validates :content, presence: true
+          validates :status, inclusion: { in: %w[draft active archived] }
+          validates :created_by, presence: true
+
+          scope :active, -> { where(status: "active") }
+          scope :for_rule, ->(rule_id) { where(rule_id: rule_id).order(version_number: :desc) }
+          scope :latest, -> { order(version_number: :desc).limit(1) }
+
+          before_create :set_next_version_number
+
+          def parsed_content
+            JSON.parse(content, symbolize_names: true)
+          rescue JSON::ParserError
+            {}
+          end
+
+          def content_hash=(hash)
+            self.content = hash.to_json
+          end
+
+          def activate!
+            transaction do
+              self.class.where(rule_id: rule_id, status: "active")
+                  .where.not(id: id)
+                  .update_all(status: "archived")
+              update!(status: "active")
+            end
+          end
+
+          private
+
+          def set_next_version_number
+            return if version_number.present?
+
+            # Use pessimistic locking to prevent race conditions
+            last_version = self.class.where(rule_id: rule_id)
+                               .order(version_number: :desc)
+                               .lock
+                               .first
+
+            self.version_number = last_version ? last_version.version_number + 1 : 1
+          end
+        end
+      end
+    end
+
+    before(:each) do
+      RuleVersion.delete_all
+    end
+
+    let(:adapter) { DecisionAgent::Versioning::ActiveRecordAdapter.new }
+    let(:rule_id) { "concurrent_test_rule" }
+    let(:rule_content) do
+      {
+        version: "1.0",
+        ruleset: "test_rules",
+        rules: [
+          {
+            id: "test_rule",
+            if: { field: "amount", op: "gt", value: 100 },
+            then: { decision: "approve", weight: 0.8, reason: "Test" }
+          }
+        ]
+      }
+    end
+
+    # Helper method to retry on SQLite busy exceptions (concurrency limitation)
+    def with_retry(max_retries: 3, &block)
+      retries = 0
+      begin
+        block.call
+      rescue ActiveRecord::StatementInvalid => e
+        raise unless e.message.include?("database is locked") && retries < max_retries
+
+        retries += 1
+        sleep(0.01 * retries) # Exponential backoff
+        retry
+      end
+    end
+
+    describe "concurrent version creation" do
+      it "prevents duplicate version numbers with pessimistic locking" do
+        thread_count = 20
+        threads = []
+        results = []
+        mutex = Mutex.new
+
+        # Spawn multiple threads creating versions concurrently
+        thread_count.times do |i|
+          threads << Thread.new do
+            version = with_retry do
+              adapter.create_version(
+                rule_id: rule_id,
+                content: rule_content.merge(thread_id: i),
+                metadata: { created_by: "thread_#{i}" }
+              )
+            end
+            mutex.synchronize { results << version }
+          end
+        end
+
+        threads.each(&:join)
+
+        # All versions should be created successfully
+        expect(results.size).to eq(thread_count)
+
+        # Version numbers must be unique and sequential
+        version_numbers = results.map { |v| v[:version_number] }.sort
+        expect(version_numbers).to eq((1..thread_count).to_a)
+
+        # Verify in database
+        db_versions = RuleVersion.where(rule_id: rule_id).order(:version_number)
+        expect(db_versions.count).to eq(thread_count)
+        expect(db_versions.pluck(:version_number)).to eq((1..thread_count).to_a)
+      end
+
+      it "handles high concurrency (100 threads)" do
+        thread_count = 100
+        threads = []
+        errors = []
+        mutex = Mutex.new
+
+        thread_count.times do |i|
+          threads << Thread.new do
+            with_retry(max_retries: 10) do # Increased retry count for high concurrency
+              adapter.create_version(
+                rule_id: rule_id,
+                content: rule_content,
+                metadata: { created_by: "thread_#{i}" }
+              )
+            end
+          rescue StandardError => e
+            mutex.synchronize { errors << e }
+          end
+        end
+
+        threads.each(&:join)
+
+        # Should have no errors
+        expect(errors).to be_empty
+
+        # All versions created with unique version numbers
+        versions = RuleVersion.where(rule_id: rule_id).order(:version_number)
+        expect(versions.count).to eq(thread_count)
+        expect(versions.pluck(:version_number)).to eq((1..thread_count).to_a)
+      end
+
+      it "maintains unique constraint even under extreme concurrency" do
+        # This test verifies the database-level unique constraint catches any edge cases
+        thread_count = 50
+        threads = []
+        successes = []
+        failures = []
+        mutex = Mutex.new
+
+        thread_count.times do |i|
+          threads << Thread.new do
+            version = with_retry do
+              adapter.create_version(
+                rule_id: rule_id,
+                content: rule_content,
+                metadata: { created_by: "thread_#{i}" }
+              )
+            end
+            mutex.synchronize { successes << version }
+          rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique => e
+            # These errors are acceptable - they mean the unique constraint caught duplicates
+            mutex.synchronize { failures << e }
+          end
+        end
+
+        threads.each(&:join)
+
+        # Either all succeed with unique versions, or some fail due to constraint
+        total_attempts = successes.size + failures.size
+        expect(total_attempts).to eq(thread_count)
+
+        # All successful versions must have unique version numbers
+        version_numbers = successes.map { |v| v[:version_number] }
+        expect(version_numbers.uniq.size).to eq(version_numbers.size)
+
+        # Database should have only unique versions
+        db_versions = RuleVersion.where(rule_id: rule_id)
+        db_version_numbers = db_versions.pluck(:version_number).sort
+        expect(db_version_numbers).to eq(db_version_numbers.uniq)
+      end
+    end
+
+    describe "concurrent read and write operations" do
+      it "allows safe concurrent reads during writes" do
+        # Create initial version
+        adapter.create_version(
+          rule_id: rule_id,
+          content: rule_content,
+          metadata: { created_by: "setup" }
+        )
+
+        threads = []
+        read_results = []
+        write_results = []
+        read_mutex = Mutex.new
+        write_mutex = Mutex.new
+
+        # Mix of readers and writers
+        20.times do |i|
+          threads << if i % 3 == 0
+                       # Write thread
+                       Thread.new do
+                         version = with_retry do
+                           adapter.create_version(
+                             rule_id: rule_id,
+                             content: rule_content,
+                             metadata: { created_by: "writer_#{i}" }
+                           )
+                         end
+                         write_mutex.synchronize { write_results << version }
+                       end
+                     else
+                       # Read thread
+                       Thread.new do
+                         versions = adapter.list_versions(rule_id: rule_id)
+                         read_mutex.synchronize { read_results << versions }
+                       end
+                     end
+        end
+
+        threads.each(&:join)
+
+        # Readers should never see corrupted data
+        read_results.each do |versions|
+          expect(versions).to be_an(Array)
+          versions.each do |v|
+            expect(v[:version_number]).to be > 0
+            expect(v[:rule_id]).to eq(rule_id)
+          end
+        end
+
+        # Writers should create valid sequential versions
+        write_version_numbers = write_results.map { |v| v[:version_number] }.sort
+        expect(write_version_numbers.first).to eq(2) # First write creates version 2
+      end
+    end
+
+    describe "status updates during concurrent creation" do
+      it "ensures only one active version at a time" do
+        thread_count = 10
+        threads = []
+
+        thread_count.times do |i|
+          threads << Thread.new do
+            with_retry do
+              adapter.create_version(
+                rule_id: rule_id,
+                content: rule_content,
+                metadata: { created_by: "thread_#{i}", status: "active" }
+              )
+            end
+          end
+        end
+
+        threads.each(&:join)
+
+        # Only the last created version should be active
+        active_versions = RuleVersion.where(rule_id: rule_id, status: "active")
+        expect(active_versions.count).to eq(1)
+
+        # The active version should be the last one
+        expect(active_versions.first.version_number).to eq(thread_count)
+
+        # All others should be archived
+        archived_versions = RuleVersion.where(rule_id: rule_id, status: "archived")
+        expect(archived_versions.count).to eq(thread_count - 1)
+      end
+    end
+
+    describe "multiple rules concurrently" do
+      it "handles version creation for different rules in parallel" do
+        rule_ids = (1..10).map { |i| "rule_#{i}" }
+        threads = []
+        results = {}
+        mutex = Mutex.new
+
+        rule_ids.each do |rid|
+          5.times do |version_index|
+            threads << Thread.new do
+              version = with_retry do
+                adapter.create_version(
+                  rule_id: rid,
+                  content: rule_content,
+                  metadata: { created_by: "creator_#{version_index}" }
+                )
+              end
+              mutex.synchronize do
+                results[rid] ||= []
+                results[rid] << version
+              end
+            end
+          end
+        end
+
+        threads.each(&:join)
+
+        # Each rule should have 5 versions
+        rule_ids.each do |rid|
+          expect(results[rid].size).to eq(5)
+          version_numbers = results[rid].map { |v| v[:version_number] }.sort
+          expect(version_numbers).to eq([1, 2, 3, 4, 5])
+        end
+      end
+    end
+
+    describe "transaction rollback on errors" do
+      it "rolls back version creation if there's an error" do
+        # Create a scenario where create might fail
+        allow(RuleVersion).to receive(:create!).and_raise(ActiveRecord::RecordInvalid.new(RuleVersion.new))
+
+        expect do
+          adapter.create_version(
+            rule_id: rule_id,
+            content: rule_content
+          )
+        end.to raise_error(ActiveRecord::RecordInvalid)
+
+        # No versions should be created
+        expect(RuleVersion.where(rule_id: rule_id).count).to eq(0)
+      end
+    end
+
+    describe "RuleVersion model callback thread safety" do
+      it "safely calculates version numbers when using model directly" do
+        thread_count = 30
+        threads = []
+        errors = []
+        mutex = Mutex.new
+
+        thread_count.times do |i|
+          threads << Thread.new do
+            RuleVersion.create!(
+              rule_id: rule_id,
+              content: rule_content.to_json,
+              created_by: "thread_#{i}",
+              status: "draft"
+            )
+          rescue StandardError => e
+            mutex.synchronize { errors << e }
+          end
+        end
+
+        threads.each(&:join)
+
+        # Should have minimal or no errors (unique constraint might catch some)
+        # The key is version numbers should be unique
+        versions = RuleVersion.where(rule_id: rule_id).order(:version_number)
+        version_numbers = versions.pluck(:version_number)
+
+        # All version numbers should be unique
+        expect(version_numbers.uniq.size).to eq(version_numbers.size)
+      end
+    end
+
+    describe "concurrent activate_version" do
+      it "prevents multiple active versions with pessimistic locking" do
+        # Create 5 versions
+        versions = 5.times.map do |i|
+          with_retry do
+            adapter.create_version(
+              rule_id: rule_id,
+              content: rule_content.merge(version: "#{i + 1}.0"),
+              metadata: { created_by: "setup_#{i}" }
+            )
+          end
+        end
+
+        # Try to activate different versions concurrently
+        thread_count = 10
+        threads = []
+        activated_versions = []
+        mutex = Mutex.new
+
+        thread_count.times do |i|
+          threads << Thread.new do
+            # Each thread tries to activate a different version (cycling through versions)
+            version_to_activate = versions[i % versions.size]
+            activated = with_retry do
+              adapter.activate_version(version_id: version_to_activate[:id])
+            end
+            mutex.synchronize { activated_versions << activated }
+          end
+        end
+
+        threads.each(&:join)
+
+        # CRITICAL: Only ONE version should be active at the end
+        active_versions = RuleVersion.where(rule_id: rule_id, status: "active")
+        expect(active_versions.count).to eq(1),
+                                         "Expected exactly 1 active version, but found #{active_versions.count}: #{active_versions.pluck(:version_number)}"
+
+        # All other versions should be archived
+        archived_versions = RuleVersion.where(rule_id: rule_id, status: "archived")
+        expect(archived_versions.count).to eq(versions.size - 1)
+
+        # The active version should be one of the versions we tried to activate
+        active_version_id = active_versions.first.id
+        expect(versions.map { |v| v[:id] }).to include(active_version_id)
+      end
+
+      it "handles race condition when two threads activate different versions simultaneously" do
+        # Create 3 versions
+        v1 = with_retry do
+          adapter.create_version(
+            rule_id: rule_id,
+            content: rule_content.merge(version: "1.0"),
+            metadata: { created_by: "setup" }
+          )
+        end
+        v2 = with_retry do
+          adapter.create_version(
+            rule_id: rule_id,
+            content: rule_content.merge(version: "2.0"),
+            metadata: { created_by: "setup" }
+          )
+        end
+        with_retry do
+          adapter.create_version(
+            rule_id: rule_id,
+            content: rule_content.merge(version: "3.0"),
+            metadata: { created_by: "setup" }
+          )
+        end
+
+        # At this point v3 is active, v1 and v2 are archived
+
+        # Spawn two threads trying to activate v1 and v2 at the same time
+        begin
+          barrier = begin
+            Concurrent::CyclicBarrier.new(2)
+          rescue StandardError
+            Thread::Barrier.new(2)
+          end
+        rescue StandardError
+          nil
+        end
+        threads = []
+
+        if barrier
+          threads << Thread.new do
+            barrier.wait
+            with_retry { adapter.activate_version(version_id: v1[:id]) }
+          end
+
+          threads << Thread.new do
+            barrier.wait
+            with_retry { adapter.activate_version(version_id: v2[:id]) }
+          end
+
+          threads.each(&:join)
+        else
+          # Fallback without barrier - still tests thread safety
+          t1 = Thread.new { with_retry { adapter.activate_version(version_id: v1[:id]) } }
+          t2 = Thread.new { with_retry { adapter.activate_version(version_id: v2[:id]) } }
+          t1.join
+          t2.join
+        end
+
+        # CRITICAL: Only ONE version should be active
+        active_count = RuleVersion.where(rule_id: rule_id, status: "active").count
+        expect(active_count).to eq(1),
+                                "Race condition detected: #{active_count} active versions found instead of 1"
+      end
+
+      it "maintains consistency across 100 concurrent activation attempts" do
+        # Create 10 versions
+        versions = 10.times.map do |i|
+          with_retry do
+            adapter.create_version(
+              rule_id: rule_id,
+              content: rule_content.merge(version: "#{i + 1}.0"),
+              metadata: { created_by: "setup_#{i}" }
+            )
+          end
+        end
+
+        # 100 threads each randomly activating versions
+        threads = 100.times.map do
+          Thread.new do
+            random_version = versions.sample
+            with_retry do
+              adapter.activate_version(version_id: random_version[:id])
+            end
+            sleep(rand * 0.01) # Small random delay to increase race condition likelihood
+          end
+        end
+
+        threads.each(&:join)
+
+        # Check consistency
+        active_versions = RuleVersion.where(rule_id: rule_id, status: "active")
+        expect(active_versions.count).to eq(1),
+                                         "Consistency violation: #{active_versions.count} active versions after concurrent activations"
+
+        # All versions should still exist
+        expect(RuleVersion.where(rule_id: rule_id).count).to eq(10)
+      end
+    end
+  end
+else
+  RSpec.describe "ActiveRecordAdapter Thread-Safety" do
+    it "skips tests when ActiveRecord is not available" do
+      skip "ActiveRecord is not loaded"
+    end
+  end
+end

data/spec/agent_spec.rb

@@ -3,41 +3,41 @@ require "spec_helper"
 RSpec.describe DecisionAgent::Agent do
   describe "#initialize" do
     it "requires at least one evaluator" do
-      expect {
+      expect do
         DecisionAgent::Agent.new(evaluators: [])
-      }.to raise_error(DecisionAgent::InvalidConfigurationError, /at least one evaluator/i)
+      end.to raise_error(DecisionAgent::InvalidConfigurationError, /at least one evaluator/i)
     end
 
     it "validates evaluators respond to #evaluate" do
       invalid_evaluator = Object.new
 
-      expect {
+      expect do
         DecisionAgent::Agent.new(evaluators: [invalid_evaluator])
-      }.to raise_error(DecisionAgent::InvalidEvaluatorError)
+      end.to raise_error(DecisionAgent::InvalidEvaluatorError)
     end
 
     it "validates scoring strategy responds to #score" do
       evaluator = DecisionAgent::Evaluators::StaticEvaluator.new(decision: "approve")
       invalid_strategy = Object.new
 
-      expect {
+      expect do
         DecisionAgent::Agent.new(
           evaluators: [evaluator],
           scoring_strategy: invalid_strategy
         )
-      }.to raise_error(DecisionAgent::InvalidScoringStrategyError)
+      end.to raise_error(DecisionAgent::InvalidScoringStrategyError)
     end
 
     it "validates audit adapter responds to #record" do
       evaluator = DecisionAgent::Evaluators::StaticEvaluator.new(decision: "approve")
       invalid_adapter = Object.new
 
-      expect {
+      expect do
         DecisionAgent::Agent.new(
           evaluators: [evaluator],
           audit_adapter: invalid_adapter
         )
-      }.to raise_error(DecisionAgent::InvalidAuditAdapterError)
+      end.to raise_error(DecisionAgent::InvalidAuditAdapterError)
     end
 
     it "uses defaults when optional parameters are omitted" do
@@ -82,21 +82,21 @@ RSpec.describe DecisionAgent::Agent do
 
     it "raises NoEvaluationsError when no evaluators return decisions" do
       failing_evaluator = Class.new(DecisionAgent::Evaluators::Base) do
-        def evaluate(context, feedback: {})
+        def evaluate(_context, feedback: {})
           nil
         end
       end
 
       agent = DecisionAgent::Agent.new(evaluators: [failing_evaluator.new])
 
-      expect {
+      expect do
         agent.decide(context: {})
-      }.to raise_error(DecisionAgent::NoEvaluationsError)
+      end.to raise_error(DecisionAgent::NoEvaluationsError)
     end
 
     it "includes feedback in evaluation" do
       feedback_evaluator = Class.new(DecisionAgent::Evaluators::Base) do
-        def evaluate(context, feedback: {})
+        def evaluate(_context, feedback: {})
           decision = feedback[:override] ? "reject" : "approve"
           DecisionAgent::Evaluation.new(
             decision: decision,
@@ -234,7 +234,7 @@ RSpec.describe DecisionAgent::Agent do
       good_evaluator = DecisionAgent::Evaluators::StaticEvaluator.new(decision: "approve")
 
       bad_evaluator = Class.new(DecisionAgent::Evaluators::Base) do
-        def evaluate(context, feedback: {})
+        def evaluate(_context, feedback: {})
           raise StandardError, "Intentional error"
         end
       end