decision_agent 0.1.3 → 0.1.6

data/spec/issue_verification_spec.rb

@@ -254,6 +254,54 @@ RSpec.describe "Issue Verification Tests" do
             )
           end.to raise_error(ActiveRecord::RecordNotUnique)
         end
+
+        it "verifies application-level constraint for single active version (all databases)" do
+          # For databases that don't support partial unique indexes (like SQLite),
+          # the application should enforce only one active version per rule
+
+          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 :status, default: "active", null: false
+              t.timestamps
+            end
+            add_index :rule_versions, %i[rule_id version_number], unique: true
+          end
+
+          class TestRuleVersion6 < ActiveRecord::Base
+            self.table_name = "rule_versions"
+
+            # Application-level validation (works on all databases)
+            validate :only_one_active_per_rule, if: -> { status == "active" }
+
+            def only_one_active_per_rule
+              existing = self.class.where(rule_id: rule_id, status: "active")
+              existing = existing.where.not(id: id) if persisted?
+              return unless existing.exists?
+
+              errors.add(:base, "Only one active version allowed per rule")
+            end
+          end
+
+          TestRuleVersion6.create!(
+            rule_id: "test_rule",
+            version_number: 1,
+            content: { test: "v1" }.to_json,
+            status: "active"
+          )
+
+          # Try to create second active version - should fail with validation error
+          expect do
+            TestRuleVersion6.create!(
+              rule_id: "test_rule",
+              version_number: 2,
+              content: { test: "v2" }.to_json,
+              status: "active"
+            )
+          end.to raise_error(ActiveRecord::RecordInvalid, /Only one active version allowed/)
+        end
       end
     end
   end
@@ -466,7 +514,11 @@ RSpec.describe "Issue Verification Tests" do
           add_index :rule_versions, %i[rule_id version_number], unique: true
         end
 
-        unless defined?(RuleVersion)
+        if defined?(RuleVersion)
+          # Clear existing validations if RuleVersion was defined by another spec
+          RuleVersion.clear_validators!
+          RuleVersion.reset_callbacks(:validate)
+        else
           class ::RuleVersion < ActiveRecord::Base
           end
         end
@@ -495,33 +547,55 @@ RSpec.describe "Issue Verification Tests" do
           end.to raise_error(DecisionAgent::ValidationError, /Invalid JSON/)
         end
 
-        it "raises ValidationError when content is empty string" do
-          # ActiveRecord validation prevents empty string content
-          skip "ActiveRecord validation prevents empty string content"
+        it "handles empty string content in JSON parsing" do
+          # Even if the database allows empty strings (no NOT NULL + no validation),
+          # the adapter should handle it gracefully when parsing JSON
+          version = RuleVersion.create!(
+            rule_id: "test_rule",
+            version_number: 1,
+            content: "", # EMPTY STRING!
+            created_by: "test",
+            status: "active"
+          )
 
-          # This test would only be relevant if the model allowed empty strings
-          # The RuleVersion model has `validates :content, presence: true`
-          # which rejects empty strings before record creation
+          # serialize_version should catch JSON parsing errors
+          expect do
+            adapter.send(:serialize_version, version)
+          end.to raise_error(DecisionAgent::ValidationError, /Invalid JSON/)
         end
 
-        it "raises ValidationError when content is nil (if allowed by DB)" do
-          # Skip this test because the schema has NOT NULL constraint on content
-          # The database won't allow nil content to be saved in the first place
-          skip "Schema has NOT NULL constraint on content column"
+        it "enforces NOT NULL constraint on content column" do
+          # The schema has NOT NULL constraint on content column
+          # The database should raise an error when trying to create with nil content
 
-          # This test would only be relevant if the schema allowed NULL content
-          # In that case, the serialize_version method already handles it with:
-          # rescue TypeError, NoMethodError
-          #   raise DecisionAgent::ValidationError, "content is nil or not a string"
+          expect do
+            RuleVersion.create!(
+              rule_id: "test_rule",
+              version_number: 1,
+              content: nil, # NIL!
+              created_by: "test",
+              status: "active"
+            )
+          end.to raise_error(ActiveRecord::NotNullViolation)
         end
 
-        it "raises ValidationError when content contains malformed UTF-8" do
-          # ActiveRecord validation rejects malformed UTF-8 before record creation
-          skip "ActiveRecord validation rejects malformed UTF-8 strings"
+        it "handles content with special UTF-8 characters correctly" do
+          # Instead of testing malformed UTF-8 (which ActiveRecord rejects),
+          # test that valid UTF-8 special characters are handled correctly
+          special_content = {
+            "unicode" => "Hello \u4E16\u754C",
+            "emoji" => "\u{1F44D}",
+            "special" => "\n\t\r"
+          }
 
-          # This test would only be relevant if ActiveRecord allowed malformed UTF-8
-          # In practice, ActiveRecord's blank? check fails on invalid UTF-8
-          # which prevents the record from being created in the first place
+          version = adapter.create_version(
+            rule_id: "test_rule",
+            content: special_content,
+            metadata: { created_by: "test" }
+          )
+
+          loaded = adapter.get_version(version_id: version[:id])
+          expect(loaded[:content]).to eq(special_content)
         end
 
         it "raises ValidationError when content is truncated JSON" do

data/spec/monitoring/metrics_collector_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "decision_agent/monitoring/metrics_collector"
 
 RSpec.describe DecisionAgent::Monitoring::MetricsCollector do
-  let(:collector) { described_class.new(window_size: 60) }
+  let(:collector) { described_class.new(window_size: 60, storage: :memory) }
   let(:decision) do
     double(
       "Decision",
@@ -266,7 +266,7 @@ RSpec.describe DecisionAgent::Monitoring::MetricsCollector do
 
   describe "metric cleanup" do
     it "removes old metrics outside window" do
-      collector = described_class.new(window_size: 1)
+      collector = described_class.new(window_size: 1, storage: :memory, cleanup_threshold: 1)
 
       collector.record_decision(decision, context)
       expect(collector.metrics_count[:decisions]).to eq(1)
@@ -274,8 +274,226 @@ RSpec.describe DecisionAgent::Monitoring::MetricsCollector do
       sleep 1.5
 
       collector.record_decision(decision, context)
-      # Old metric should be cleaned up
+      # Old metric should be cleaned up (threshold=1 means cleanup on every record)
       expect(collector.metrics_count[:decisions]).to eq(1)
     end
   end
+
+  describe "#record_evaluation" do
+    let(:evaluation) do
+      double(
+        "Evaluation",
+        decision: "approve",
+        weight: 0.9,
+        evaluator_name: "test_evaluator"
+      )
+    end
+
+    it "notifies observers" do
+      observed = []
+      collector.add_observer do |type, metric|
+        observed << [type, metric]
+      end
+
+      collector.record_evaluation(evaluation)
+
+      expect(observed.size).to eq(1)
+      expect(observed[0][0]).to eq(:evaluation)
+      expect(observed[0][1][:decision]).to eq("approve")
+    end
+  end
+
+  describe "#record_performance" do
+    it "notifies observers" do
+      observed = []
+      collector.add_observer do |type, metric|
+        observed << [type, metric]
+      end
+
+      collector.record_performance(operation: "test", duration_ms: 10.0, success: true)
+
+      expect(observed.size).to eq(1)
+      expect(observed[0][0]).to eq(:performance)
+      expect(observed[0][1][:operation]).to eq("test")
+    end
+  end
+
+  describe "#record_error" do
+    it "notifies observers" do
+      observed = []
+      collector.add_observer do |type, metric|
+        observed << [type, metric]
+      end
+
+      collector.record_error(StandardError.new("Test"))
+
+      expect(observed.size).to eq(1)
+      expect(observed[0][0]).to eq(:error)
+      expect(observed[0][1][:error_class]).to eq("StandardError")
+    end
+
+    it "handles different error types" do
+      expect { collector.record_error(ArgumentError.new("Arg error")) }.not_to raise_error
+      expect { collector.record_error(TypeError.new("Type error")) }.not_to raise_error
+      expect { collector.record_error(Exception.new("Exception")) }.not_to raise_error
+    end
+  end
+
+  describe "#add_observer" do
+    it "adds an observer callback" do
+      callback = proc { |type, metric| }
+      collector.add_observer(&callback)
+      # Observer should be stored
+      expect(collector.instance_variable_get(:@observers)).to include(callback)
+    end
+
+    it "handles observer errors gracefully" do
+      # Add observer that raises error
+      collector.add_observer do |_type, _metric|
+        raise "Observer error"
+      end
+
+      # Should not raise, just warn
+      expect { collector.record_decision(decision, context) }.not_to raise_error
+    end
+  end
+
+  describe "#statistics" do
+    before do
+      3.times do
+        evaluation = double("Evaluation", decision: "approve", weight: 0.8, evaluator_name: "eval1")
+        collector.record_evaluation(evaluation)
+      end
+      2.times do
+        evaluation = double("Evaluation", decision: "reject", weight: 0.6, evaluator_name: "eval2")
+        collector.record_evaluation(evaluation)
+      end
+    end
+
+    it "computes evaluation statistics" do
+      stats = collector.statistics
+      expect(stats[:evaluations][:total]).to eq(5)
+      expect(stats[:evaluations][:avg_weight]).to be_within(0.01).of(0.72)
+    end
+
+    it "handles empty decisions gracefully" do
+      empty_collector = described_class.new(storage: :memory)
+      stats = empty_collector.statistics
+      expect(stats[:decisions]).to eq({})
+    end
+
+    it "handles decisions without duration_ms" do
+      decision_no_duration = double(
+        "Decision",
+        decision: "approve",
+        confidence: 0.5,
+        evaluations: []
+      )
+      collector.record_decision(decision_no_duration, context)
+      stats = collector.statistics
+      expect(stats[:decisions][:avg_duration_ms]).to be_nil
+    end
+  end
+
+  describe "#time_series" do
+    it "handles empty metric types" do
+      series = collector.time_series(metric_type: :nonexistent, bucket_size: 60, time_range: 3600)
+      expect(series).to eq([])
+    end
+
+    it "filters metrics by time range" do
+      # Record some old metrics (simulated)
+      old_time = Time.now.utc - 7200
+      allow(Time).to receive(:now).and_return(Time.at(old_time.to_i))
+      5.times { collector.record_decision(decision, context) }
+
+      # Record new metrics
+      allow(Time).to receive(:now).and_call_original
+      3.times { collector.record_decision(decision, context) }
+
+      series = collector.time_series(metric_type: :decisions, bucket_size: 60, time_range: 3600)
+      # Should only include recent metrics
+      total = series.sum { |s| s[:count] }
+      expect(total).to be <= 3
+    end
+  end
+
+  describe "#cleanup_old_metrics_from_storage" do
+    it "delegates to storage adapter if it has cleanup method" do
+      # Using memory adapter which doesn't have cleanup
+      expect(collector.cleanup_old_metrics_from_storage(older_than: 3600)).to eq(0)
+    end
+  end
+
+  describe "#initialize_storage_adapter" do
+    it "uses memory storage when :memory specified" do
+      collector = described_class.new(storage: :memory)
+      expect(collector.storage_adapter).to be_a(DecisionAgent::Monitoring::Storage::MemoryAdapter)
+    end
+
+    it "raises error for unknown storage option" do
+      expect do
+        described_class.new(storage: :unknown)
+      end.to raise_error(ArgumentError, /Unknown storage option/)
+    end
+  end
+
+  describe "error severity determination" do
+    it "determines severity for ArgumentError as medium" do
+      error = ArgumentError.new("test")
+      collector.record_error(error)
+      # Just verify it doesn't raise
+      expect(collector.metrics_count[:errors]).to eq(1)
+    end
+
+    it "determines severity for TypeError as medium" do
+      error = TypeError.new("test")
+      collector.record_error(error)
+      expect(collector.metrics_count[:errors]).to eq(1)
+    end
+
+    it "determines severity for Exception as critical" do
+      error = Exception.new("test")
+      collector.record_error(error)
+      expect(collector.metrics_count[:errors]).to eq(1)
+    end
+  end
+
+  describe "decision status determination" do
+    it "determines status for high confidence decisions" do
+      high_conf_decision = double(
+        "Decision",
+        decision: "approve",
+        confidence: 0.9,
+        evaluations: []
+      )
+      collector.record_decision(high_conf_decision, context)
+      # Just verify it records successfully
+      expect(collector.metrics_count[:decisions]).to eq(1)
+    end
+
+    it "determines status for low confidence decisions" do
+      low_conf_decision = double(
+        "Decision",
+        decision: "approve",
+        confidence: 0.2,
+        evaluations: []
+      )
+      collector.record_decision(low_conf_decision, context)
+      expect(collector.metrics_count[:decisions]).to eq(1)
+    end
+  end
+
+  describe "#compute_performance_stats" do
+    it "computes percentile statistics" do
+      durations = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
+      durations.each do |duration|
+        collector.record_performance(operation: "test", duration_ms: duration, success: true)
+      end
+
+      stats = collector.statistics
+      expect(stats[:performance][:p95_duration_ms]).to be >= 90
+      expect(stats[:performance][:p99_duration_ms]).to be >= 95
+    end
+  end
 end

data/spec/monitoring/monitored_agent_spec.rb

@@ -3,7 +3,7 @@ require "decision_agent/monitoring/metrics_collector"
 require "decision_agent/monitoring/monitored_agent"
 
 RSpec.describe DecisionAgent::Monitoring::MonitoredAgent do
-  let(:collector) { DecisionAgent::Monitoring::MetricsCollector.new }
+  let(:collector) { DecisionAgent::Monitoring::MetricsCollector.new(storage: :memory) }
   let(:evaluator) do
     double(
       "Evaluator",

data/spec/monitoring/prometheus_exporter_spec.rb

@@ -3,7 +3,7 @@ require "decision_agent/monitoring/metrics_collector"
 require "decision_agent/monitoring/prometheus_exporter"
 
 RSpec.describe DecisionAgent::Monitoring::PrometheusExporter do
-  let(:collector) { DecisionAgent::Monitoring::MetricsCollector.new }
+  let(:collector) { DecisionAgent::Monitoring::MetricsCollector.new(storage: :memory) }
   let(:exporter) { described_class.new(metrics_collector: collector, namespace: "test") }
 
   let(:decision) do