spec_scout 0.1.0

data/lib/spec_scout/agents/factory_agent.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require_relative '../base_agent'
+
+module SpecScout
+  module Agents
+    # Agent that evaluates FactoryBot strategy appropriateness and recommends optimizations
+    class FactoryAgent < BaseAgent
+      # Verdict types for factory strategy optimization
+      VERDICTS = {
+        prefer_build_stubbed: :prefer_build_stubbed,
+        create_required: :create_required,
+        strategy_optimal: :strategy_optimal
+      }.freeze
+
+      def evaluate
+        return no_factory_data_result unless factories_present?
+
+        factory_analysis = analyze_factory_usage
+
+        verdict, confidence, reasoning = determine_recommendation(factory_analysis)
+
+        create_result(
+          verdict: verdict,
+          confidence: confidence,
+          reasoning: reasoning,
+          metadata: factory_analysis
+        )
+      end
+
+      private
+
+      def analyze_factory_usage
+        create_count = 0
+        build_stubbed_count = 0
+        total_factories = 0
+        factory_details = {}
+        association_access_detected = false
+
+        profile_data.factories.each do |factory_name, factory_data|
+          next unless factory_data.is_a?(Hash)
+
+          strategy = factory_data[:strategy] || :unknown
+          count = factory_data[:count] || 0
+          associations = factory_data[:associations] || []
+
+          total_factories += count
+          factory_details[factory_name] = factory_data
+
+          # Check for association access patterns
+          association_access_detected = true if associations.any? || association_indicators?(factory_data)
+
+          case strategy
+          when :create
+            create_count += count
+          when :build_stubbed
+            build_stubbed_count += count
+          end
+        end
+
+        {
+          create_count: create_count,
+          build_stubbed_count: build_stubbed_count,
+          total_factories: total_factories,
+          factory_details: factory_details,
+          database_writes: profile_data.db[:inserts] || 0,
+          association_access_detected: association_access_detected
+        }
+      end
+
+      def determine_recommendation(analysis)
+        create_count = analysis[:create_count]
+        build_stubbed_count = analysis[:build_stubbed_count]
+        database_writes = analysis[:database_writes]
+        association_access = analysis[:association_access_detected]
+
+        if prefer_build_stubbed?(create_count, database_writes, association_access)
+          prefer_build_stubbed_result(create_count)
+        elsif create_required_association?(create_count, association_access)
+          create_required_association_result
+        elsif create_required_db?(create_count, database_writes)
+          create_required_db_result(database_writes, create_count)
+        elsif strategy_optimal?(build_stubbed_count, create_count)
+          strategy_optimal_result(build_stubbed_count)
+        else
+          mixed_usage_result
+        end
+      end
+
+      def prefer_build_stubbed?(create_count, database_writes, association_access)
+        create_count.positive? && database_writes.zero? && !association_access
+      end
+
+      def create_required_association?(create_count, association_access)
+        create_count.positive? && association_access
+      end
+
+      def create_required_db?(create_count, database_writes)
+        create_count.positive? && database_writes.positive?
+      end
+
+      def strategy_optimal?(build_stubbed_count, create_count)
+        build_stubbed_count.positive? && create_count.zero?
+      end
+
+      def prefer_build_stubbed_result(create_count)
+        [
+          VERDICTS[:prefer_build_stubbed],
+          :medium,
+          "Using create strategy (#{create_count} factories) but no database writes or association access detected. " \
+          'Consider using build_stubbed for better performance.'
+        ]
+      end
+
+      def create_required_association_result
+        [
+          VERDICTS[:create_required],
+          :medium,
+          'Using create strategy with association access patterns detected. ' \
+          'Factory persistence may be necessary for association handling.'
+        ]
+      end
+
+      def create_required_db_result(database_writes, _create_count)
+        [
+          VERDICTS[:create_required],
+          :medium,
+          "Using create strategy with database writes (#{database_writes} inserts). " \
+          'Factory persistence appears necessary.'
+        ]
+      end
+
+      def strategy_optimal_result(build_stubbed_count)
+        [
+          VERDICTS[:strategy_optimal],
+          :high,
+          "Already using build_stubbed strategy (#{build_stubbed_count} factories). " \
+          'Factory strategy is optimized.'
+        ]
+      end
+
+      def mixed_usage_result
+        [
+          VERDICTS[:strategy_optimal],
+          :low,
+          'Mixed factory usage pattern. Current strategy appears reasonable.'
+        ]
+      end
+
+      def no_factory_data_result
+        create_result(
+          verdict: VERDICTS[:strategy_optimal],
+          confidence: :low,
+          reasoning: 'No factory usage data available for analysis.',
+          metadata: { no_data: true }
+        )
+      end
+
+      # Helper method to detect association access patterns in factory data
+      def association_indicators?(factory_data)
+        traits_with_association?(factory_data) ||
+          attributes_with_foreign_key?(factory_data) ||
+          build_strategy_with_associations?(factory_data)
+      end
+
+      def traits_with_association?(factory_data)
+        factory_data[:traits]&.any? { |trait| trait.to_s.include?('with_') }
+      end
+
+      def attributes_with_foreign_key?(factory_data)
+        factory_data[:attributes]&.keys&.any? { |attr| attr.to_s.end_with?('_id') }
+      end
+
+      def build_strategy_with_associations?(factory_data)
+        factory_data[:build_strategy] == :create && factory_data[:associations_count].to_i.positive?
+      end
+    end
+  end
+end

data/lib/spec_scout/agents/intent_agent.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require_relative '../base_agent'
+
+module SpecScout
+  module Agents
+    # Agent that classifies test intent and behavior patterns to determine
+    # if tests are behaving as unit or integration tests
+    class IntentAgent < BaseAgent
+      # Verdict types for test intent classification
+      VERDICTS = {
+        unit_test_behavior: :unit_test_behavior,
+        integration_test_behavior: :integration_test_behavior,
+        intent_unclear: :intent_unclear
+      }.freeze
+
+      # File path patterns that indicate different test types
+      UNIT_TEST_PATTERNS = [
+        %r{spec/models/},
+        %r{spec/lib/},
+        %r{spec/services/},
+        %r{spec/helpers/},
+        %r{spec/presenters/},
+        %r{spec/decorators/},
+        %r{spec/serializers/},
+        %r{spec/validators/},
+        %r{spec/concerns/},
+        %r{spec/jobs/}
+      ].freeze
+
+      INTEGRATION_TEST_PATTERNS = [
+        %r{spec/features/},
+        %r{spec/integration/},
+        %r{spec/system/},
+        %r{spec/requests/},
+        %r{spec/controllers/},
+        %r{spec/routing/},
+        %r{spec/views/},
+        %r{spec/mailers/}
+      ].freeze
+
+      def evaluate
+        return no_location_data_result if profile_data.example_location.empty?
+
+        file_location_signal = analyze_file_location
+        runtime_behavior_signal = analyze_runtime_behavior
+        database_usage_signal = analyze_database_usage
+        factory_usage_signal = analyze_factory_usage
+
+        verdict, confidence, reasoning = determine_intent(
+          file_location: file_location_signal,
+          runtime_behavior: runtime_behavior_signal,
+          database_usage: database_usage_signal,
+          factory_usage: factory_usage_signal
+        )
+
+        create_result(
+          verdict: verdict,
+          confidence: confidence,
+          reasoning: reasoning,
+          metadata: {
+            file_location_signal: file_location_signal,
+            runtime_behavior_signal: runtime_behavior_signal,
+            database_usage_signal: database_usage_signal,
+            factory_usage_signal: factory_usage_signal,
+            runtime_ms: profile_data.runtime_ms
+          }
+        )
+      end
+
+      private
+
+      def analyze_file_location
+        location = profile_data.example_location.downcase
+
+        if UNIT_TEST_PATTERNS.any? { |pattern| location.match?(pattern) }
+          :unit_test_location
+        elsif INTEGRATION_TEST_PATTERNS.any? { |pattern| location.match?(pattern) }
+          :integration_test_location
+        else
+          :unclear_location
+        end
+      end
+
+      def analyze_runtime_behavior
+        runtime = profile_data.runtime_ms
+
+        case runtime
+        when 0..10
+          :fast_execution # Typical unit test speed
+        when 11..100
+          :moderate_execution # Could be either
+        else
+          :slow_execution # Likely integration test
+        end
+      end
+
+      def analyze_database_usage
+        return :no_database_data unless database_operations_present?
+
+        total_queries = profile_data.db[:total_queries] || 0
+        profile_data.db[:inserts] || 0
+
+        case total_queries
+        when 0..2
+          :minimal_database # Unit test pattern
+        when 3..10
+          :moderate_database # Could be either
+        else
+          :heavy_database # Integration test pattern
+        end
+      end
+
+      def analyze_factory_usage
+        return :no_factory_data unless factories_present?
+
+        factory_count = profile_data.factories.values.sum { |factory| factory[:count] || 0 }
+        create_usage = profile_data.factories.values.count { |factory| factory[:strategy] == :create }
+
+        if factory_count <= 1 && create_usage.zero?
+          :minimal_factories # Unit test pattern
+        elsif factory_count > 5 || create_usage > 3
+          :heavy_factories # Integration test pattern
+        else
+          :moderate_factories # Could be either
+        end
+      end
+
+      def determine_intent(file_location:, runtime_behavior:, database_usage:, factory_usage:)
+        unit_signals = count_unit_signals(file_location, runtime_behavior, database_usage, factory_usage)
+        integration_signals = count_integration_signals(file_location, runtime_behavior, database_usage, factory_usage)
+
+        if unit_signals >= 3
+          unit_test_result(unit_signals, integration_signals)
+        elsif integration_signals >= 3
+          integration_test_result(unit_signals, integration_signals)
+        elsif unit_signals >= 2 && integration_signals.zero?
+          unit_test_result_medium_confidence(unit_signals, integration_signals)
+        elsif integration_signals >= 2 && unit_signals.zero?
+          integration_test_result_medium_confidence(unit_signals, integration_signals)
+        elsif unit_signals > integration_signals && unit_signals >= 1
+          unit_test_result_medium_confidence(unit_signals, integration_signals)
+        elsif integration_signals > unit_signals && integration_signals >= 1
+          integration_test_result_medium_confidence(unit_signals, integration_signals)
+        else
+          unclear_intent_result(unit_signals, integration_signals)
+        end
+      end
+
+      def count_unit_signals(file_location, runtime_behavior, database_usage, factory_usage)
+        signals = 0
+        signals += 1 if file_location == :unit_test_location
+        signals += 1 if runtime_behavior == :fast_execution
+        signals += 1 if database_usage == :minimal_database
+        signals += 1 if factory_usage == :minimal_factories
+        signals
+      end
+
+      def count_integration_signals(file_location, runtime_behavior, database_usage, factory_usage)
+        signals = 0
+        signals += 1 if file_location == :integration_test_location
+        signals += 1 if runtime_behavior == :slow_execution
+        signals += 1 if database_usage == :heavy_database
+        signals += 1 if factory_usage == :heavy_factories
+        signals
+      end
+
+      def unit_test_result(unit_signals, integration_signals)
+        [
+          VERDICTS[:unit_test_behavior],
+          :high,
+          "Strong unit test behavior detected (#{unit_signals} unit signals, #{integration_signals} integration signals). " \
+          'Test appears to focus on isolated component behavior.'
+        ]
+      end
+
+      def integration_test_result(unit_signals, integration_signals)
+        [
+          VERDICTS[:integration_test_behavior],
+          :high,
+          "Strong integration test behavior detected (#{integration_signals} integration signals, #{unit_signals} unit signals). " \
+          'Test appears to cross integration boundaries.'
+        ]
+      end
+
+      def unit_test_result_medium_confidence(unit_signals, integration_signals)
+        [
+          VERDICTS[:unit_test_behavior],
+          :medium,
+          "Likely unit test behavior (#{unit_signals} unit signals, #{integration_signals} integration signals). " \
+          'Some mixed signals present but unit test patterns dominate.'
+        ]
+      end
+
+      def integration_test_result_medium_confidence(unit_signals, integration_signals)
+        [
+          VERDICTS[:integration_test_behavior],
+          :medium,
+          "Likely integration test behavior (#{integration_signals} integration signals, #{unit_signals} unit signals). " \
+          'Some mixed signals present but integration test patterns dominate.'
+        ]
+      end
+
+      def unclear_intent_result(unit_signals, integration_signals)
+        [
+          VERDICTS[:intent_unclear],
+          :low,
+          "Mixed behavioral signals detected (#{unit_signals} unit signals, #{integration_signals} integration signals). " \
+          'Unable to clearly classify test intent.'
+        ]
+      end
+
+      def no_location_data_result
+        create_result(
+          verdict: VERDICTS[:intent_unclear],
+          confidence: :low,
+          reasoning: 'No spec location data available for intent analysis.',
+          metadata: { no_data: true }
+        )
+      end
+    end
+  end
+end

data/lib/spec_scout/agents/risk_agent.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require_relative '../base_agent'
+
+module SpecScout
+  module Agents
+    # Agent that identifies potentially unsafe optimization scenarios by detecting
+    # after_commit callbacks, complex callback chains, and side-effect indicators
+    class RiskAgent < BaseAgent
+      # Verdict types for risk assessment
+      VERDICTS = {
+        safe_to_optimize: :safe_to_optimize,
+        potential_side_effects: :potential_side_effects,
+        high_risk: :high_risk
+      }.freeze
+
+      # Event patterns that indicate potential side effects
+      SIDE_EFFECT_EVENT_PATTERNS = [
+        /after_commit/i,
+        /after_create/i,
+        /after_update/i,
+        /after_save/i,
+        /after_destroy/i,
+        /callback/i,
+        /mailer/i,
+        /job/i,
+        /queue/i,
+        /background/i,
+        /sidekiq/i,
+        /resque/i,
+        /delayed_job/i
+      ].freeze
+
+      # Metadata keys that might indicate side effects
+      SIDE_EFFECT_METADATA_KEYS = %i[
+        callbacks
+        after_commit
+        after_create
+        after_update
+        after_save
+        mailers
+        jobs
+        background_jobs
+        side_effects
+        external_calls
+        api_calls
+        webhooks
+      ].freeze
+
+      # Factory patterns that suggest complex object creation with potential callbacks
+      COMPLEX_FACTORY_PATTERNS = [
+        /with_.*callback/i,
+        /with_.*job/i,
+        /with_.*mailer/i,
+        /with_.*notification/i,
+        /with_.*webhook/i,
+        /published/i,
+        /activated/i,
+        /confirmed/i
+      ].freeze
+
+      def evaluate
+        callback_indicators = detect_callback_indicators
+        side_effect_indicators = detect_side_effect_indicators
+        complex_chain_indicators = detect_complex_callback_chains
+        factory_risk_indicators = detect_factory_risk_patterns
+
+        risk_score = calculate_risk_score(
+          callback_indicators: callback_indicators,
+          side_effect_indicators: side_effect_indicators,
+          complex_chain_indicators: complex_chain_indicators,
+          factory_risk_indicators: factory_risk_indicators
+        )
+
+        verdict, confidence, reasoning = determine_risk_level(
+          risk_score: risk_score,
+          callback_indicators: callback_indicators,
+          side_effect_indicators: side_effect_indicators,
+          complex_chain_indicators: complex_chain_indicators,
+          factory_risk_indicators: factory_risk_indicators
+        )
+
+        create_result(
+          verdict: verdict,
+          confidence: confidence,
+          reasoning: reasoning,
+          metadata: {
+            risk_score: risk_score,
+            callback_indicators: callback_indicators,
+            side_effect_indicators: side_effect_indicators,
+            complex_chain_indicators: complex_chain_indicators,
+            factory_risk_indicators: factory_risk_indicators,
+            total_risk_factors: callback_indicators.size + side_effect_indicators.size +
+                               complex_chain_indicators.size + factory_risk_indicators.size
+          }
+        )
+      end
+
+      private
+
+      def detect_callback_indicators
+        indicators = []
+
+        # Check events data for callback-related patterns
+        if profile_data.events.is_a?(Hash)
+          profile_data.events.each do |event_name, event_data|
+            event_string = "#{event_name} #{event_data}".downcase
+            SIDE_EFFECT_EVENT_PATTERNS.each do |pattern|
+              if event_string.match?(pattern)
+                indicators << { type: :event_pattern, pattern: pattern.source, event: event_name }
+              end
+            end
+          end
+        end
+
+        # Check metadata for callback indicators
+        if profile_data.metadata.is_a?(Hash)
+          SIDE_EFFECT_METADATA_KEYS.each do |key|
+            if profile_data.metadata.key?(key) && profile_data.metadata[key]
+              indicators << { type: :metadata_key, key: key, value: profile_data.metadata[key] }
+            end
+          end
+        end
+
+        indicators
+      end
+
+      def detect_side_effect_indicators
+        indicators = []
+
+        # High database write activity might indicate complex side effects
+        if database_operations_present?
+          inserts = profile_data.db[:inserts] || 0
+          updates = profile_data.db[:updates] || 0
+          deletes = profile_data.db[:deletes] || 0
+
+          total_writes = inserts + updates + deletes
+          indicators << { type: :high_db_writes, count: total_writes } if total_writes > 5
+        end
+
+        # Multiple factory creation might indicate complex object graphs with callbacks
+        if factories_present?
+          total_create_factories = profile_data.factories.values.sum do |factory_data|
+            factory_data[:strategy] == :create ? (factory_data[:count] || 0) : 0
+          end
+
+          if total_create_factories > 3
+            indicators << { type: :multiple_create_factories, count: total_create_factories }
+          end
+        end
+
+        # Long runtime might indicate complex processing with side effects
+        indicators << { type: :long_runtime, runtime_ms: profile_data.runtime_ms } if profile_data.runtime_ms > 500
+
+        indicators
+      end
+
+      def detect_complex_callback_chains
+        indicators = []
+
+        # Check for multiple event types which might indicate callback chains
+        if profile_data.events.is_a?(Hash) && profile_data.events.size > 3
+          indicators << { type: :multiple_events, count: profile_data.events.size }
+        end
+
+        # Check for nested or chained operations in metadata
+        if profile_data.metadata.is_a?(Hash) && (profile_data.metadata[:nested_operations] || profile_data.metadata[:chained_callbacks])
+          indicators << { type: :nested_operations, metadata: profile_data.metadata }
+        end
+
+        indicators
+      end
+
+      def detect_factory_risk_patterns
+        indicators = []
+
+        return indicators unless factories_present?
+
+        profile_data.factories.each do |factory_name, factory_data|
+          next unless factory_data.is_a?(Hash)
+
+          # Check factory traits for risky patterns
+          if factory_data[:traits].is_a?(Array)
+            factory_data[:traits].each do |trait|
+              trait_string = trait.to_s
+              COMPLEX_FACTORY_PATTERNS.each do |pattern|
+                next unless trait_string.match?(pattern)
+
+                indicators << {
+                  type: :risky_factory_trait,
+                  factory: factory_name,
+                  trait: trait,
+                  pattern: pattern.source
+                }
+              end
+            end
+          end
+
+          # Check for factories with many associations (potential callback triggers)
+          associations_count = factory_data[:associations]&.size || 0
+          next unless associations_count > 2
+
+          indicators << {
+            type: :complex_associations,
+            factory: factory_name,
+            associations_count: associations_count
+          }
+        end
+
+        indicators
+      end
+
+      def calculate_risk_score(callback_indicators:, side_effect_indicators:, complex_chain_indicators:,
+                               factory_risk_indicators:)
+        score = 0
+
+        # Weight different types of risk indicators
+        score += callback_indicators.size * 2      # Callback indicators are high risk
+        score += side_effect_indicators.size * 2   # Side effect indicators are medium risk
+        score += complex_chain_indicators.size * 2 # Complex chains are medium risk
+        score += factory_risk_indicators.size * 1  # Factory risks are lower but still concerning
+
+        score
+      end
+
+      def determine_risk_level(risk_score:, callback_indicators:, side_effect_indicators:, complex_chain_indicators:,
+                               factory_risk_indicators:)
+        total_indicators = callback_indicators.size + side_effect_indicators.size +
+                           complex_chain_indicators.size + factory_risk_indicators.size
+
+        if risk_score >= 8 || callback_indicators.size >= 3
+          high_risk_result(risk_score, total_indicators)
+        elsif risk_score >= 4 || callback_indicators.size >= 2 || total_indicators >= 4
+          potential_side_effects_result(risk_score, total_indicators)
+        elsif risk_score >= 2 || total_indicators >= 2
+          potential_side_effects_medium_confidence_result(risk_score, total_indicators)
+        elsif risk_score >= 1 || total_indicators >= 1
+          potential_side_effects_low_confidence_result(risk_score, total_indicators)
+        else
+          safe_to_optimize_result
+        end
+      end
+
+      def high_risk_result(risk_score, total_indicators)
+        [
+          VERDICTS[:high_risk],
+          :high,
+          "High risk optimization scenario detected (risk score: #{risk_score}, #{total_indicators} risk factors). " \
+          'Strong indicators of callbacks or side effects present. Optimization not recommended.'
+        ]
+      end
+
+      def potential_side_effects_result(risk_score, total_indicators)
+        [
+          VERDICTS[:potential_side_effects],
+          :medium,
+          "Potential side effects detected (risk score: #{risk_score}, #{total_indicators} risk factors). " \
+          'Some indicators suggest callbacks or side effects may be present. Proceed with caution.'
+        ]
+      end
+
+      def potential_side_effects_medium_confidence_result(risk_score, total_indicators)
+        [
+          VERDICTS[:potential_side_effects],
+          :medium,
+          "Potential side effects detected (risk score: #{risk_score}, #{total_indicators} risk factors). " \
+          'Multiple indicators suggest callbacks or side effects may be present. Proceed with caution.'
+        ]
+      end
+
+      def potential_side_effects_low_confidence_result(risk_score, total_indicators)
+        [
+          VERDICTS[:potential_side_effects],
+          :low,
+          "Minor risk indicators detected (risk score: #{risk_score}, #{total_indicators} risk factors). " \
+          'Weak signals suggest potential side effects. Optimization likely safe but monitor carefully.'
+        ]
+      end
+
+      def safe_to_optimize_result
+        [
+          VERDICTS[:safe_to_optimize],
+          :high,
+          'No risk factors detected. No indicators of callbacks, side effects, or complex chains found. ' \
+          'Optimization appears safe to proceed.'
+        ]
+      end
+    end
+  end
+end