cov-loupe 3.0.0 → 4.0.0.pre

data/spec/error_mode_spec.rb

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'Error Mode System' do
-  let(:test_logger) do
-    Class.new do
-      attr_reader :messages
-
-      def initialize = @messages = []
-      def error(msg) = @messages << msg
-    end.new
-  end
-
-  let(:test_error) { StandardError.new('Test error message') }
-
-  describe 'ErrorHandler error modes' do
-    context 'with error_mode: :off' do
-      subject(:handler) { CovLoupe::ErrorHandler.new(error_mode: :off, logger: test_logger) }
-
-      it 'does not log errors' do
-        expect(handler.log_errors?).to be false
-        expect(handler.show_stack_traces?).to be false
-
-        handler.handle_error(test_error, context: 'test', reraise: false)
-        expect(test_logger.messages).to be_empty
-      end
-    end
-
-    context 'with error_mode: :log' do
-      subject(:handler) { CovLoupe::ErrorHandler.new(error_mode: :log, logger: test_logger) }
-
-      it 'logs errors but not stack traces' do
-        expect(handler.log_errors?).to be true
-        expect(handler.show_stack_traces?).to be false
-
-        handler.handle_error(test_error, context: 'test', reraise: false)
-        logged_message = test_logger.messages.join
-        expect(logged_message).to include('Error in test: StandardError: Test error message')
-        expect(logged_message).not_to include('spec/error_mode_spec.rb') # No stack trace
-      end
-    end
-
-    context 'with error_mode: :debug' do
-      subject(:handler) { CovLoupe::ErrorHandler.new(error_mode: :debug, logger: test_logger) }
-
-      it 'logs errors with stack traces' do
-        expect(handler.log_errors?).to be true
-        expect(handler.show_stack_traces?).to be true
-
-        # Create an error with a proper backtrace
-        begin
-          raise StandardError, 'Test error message'
-        rescue => e
-          handler.handle_error(e, context: 'test', reraise: false)
-        end
-
-        logged_message = test_logger.messages.join
-        expect(logged_message).to include('Error in test: StandardError: Test error message')
-        expect(logged_message).to include('spec/error_mode_spec.rb') # Stack trace included
-      end
-    end
-  end
-
-  describe 'ErrorHandlerFactory' do
-    it 'creates handlers with correct modes' do
-      cli_handler = CovLoupe::ErrorHandlerFactory.for_cli(error_mode: :debug)
-      expect(cli_handler.error_mode).to eq(:debug)
-
-      lib_handler = CovLoupe::ErrorHandlerFactory.for_library(error_mode: :off)
-      expect(lib_handler.error_mode).to eq(:off)
-
-      mcp_handler = CovLoupe::ErrorHandlerFactory.for_mcp_server(error_mode: :log)
-      expect(mcp_handler.error_mode).to eq(:log)
-    end
-  end
-
-  describe 'MCP Tools error mode support' do
-    before { setup_mcp_response_stub }
-
-    it 'BaseTool.handle_mcp_error respects error modes' do
-      test_error = StandardError.new('Test MCP error')
-
-      # Test different error modes
-      [:off, :log, :debug].each do |mode|
-        expect(CovLoupe::ErrorHandlerFactory)
-          .to receive(:for_mcp_server).with(error_mode: mode).and_call_original
-
-        response = CovLoupe::BaseTool.handle_mcp_error(test_error, 'TestTool', error_mode: mode)
-        expect(response).to be_a(MCP::Tool::Response)
-        expect(response.payload.first['text']).to include('Error:')
-      end
-    end
-  end
-
-  describe 'CLI error mode support' do
-    let(:project_dir) { File.join(__dir__, 'fixtures', 'project1') }
-
-    it 'accepts --error-mode flag' do
-      cli = CovLoupe::CoverageCLI.new
-
-      # Test that the option parser accepts the flag
-      expect do
-        cli.send(:parse_options!, ['--error-mode', 'debug', 'summary', 'lib/foo.rb'])
-      end.not_to raise_error
-
-      expect(cli.config.error_mode).to eq(:debug)
-    end
-
-    it 'creates error handler with specified mode' do
-      cli = CovLoupe::CoverageCLI.new
-      cli.send(:parse_options!, ['--error-mode', 'off', 'summary', 'lib/foo.rb'])
-
-      expect(cli.send(:error_handler).error_mode).to eq(:off)
-    end
-
-    it 'validates error mode values' do
-      cli = CovLoupe::CoverageCLI.new
-
-      expect do
-        cli.send(:parse_options!, ['--error-mode', 'invalid', 'summary', 'lib/foo.rb'])
-      end.to raise_error(OptionParser::InvalidArgument)
-    end
-  end
-
-  describe 'Error mode validation' do
-    it 'raises ArgumentError for invalid error modes' do
-      expect do
-        CovLoupe::ErrorHandler.new(error_mode: :invalid)
-      end.to raise_error(ArgumentError, /Invalid error_mode: :invalid/)
-    end
-
-    it 'accepts all valid error modes' do
-      expect { CovLoupe::ErrorHandler.new(error_mode: :off) }.not_to raise_error
-      expect { CovLoupe::ErrorHandler.new(error_mode: :log) }.not_to raise_error
-      expect { CovLoupe::ErrorHandler.new(error_mode: :debug) }.not_to raise_error
-    end
-  end
-end

data/spec/errors_edge_cases_spec.rb

@@ -1,312 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe CovLoupe do
-  describe CovLoupe::ConfigurationError do
-    describe '#user_friendly_message' do
-      it 'prefixes message with "Configuration error:"' do
-        error = described_class.new('Invalid option value')
-
-        expect(error.user_friendly_message).to eq('Configuration error: Invalid option value')
-      end
-
-      it 'handles empty message' do
-        error = described_class.new('')
-
-        expect(error.user_friendly_message).to eq('Configuration error: ')
-      end
-
-      it 'handles nil message' do
-        # When nil is passed to StandardError, it uses the class name as the message
-        error = described_class.new(nil)
-
-        expect(error.user_friendly_message).to eq('Configuration error: CovLoupe::ConfigurationError')
-      end
-    end
-  end
-
-
-  describe CovLoupe::ResultsetNotFoundError do
-    describe '#user_friendly_message' do
-      it 'includes helpful tips in CLI mode' do
-        # Create a CLI context (not MCP mode)
-        error_handler = CovLoupe::ErrorHandlerFactory.for_cli
-        context = CovLoupe.create_context(error_handler: error_handler, mode: :cli)
-        CovLoupe.with_context(context) do
-          error = described_class.new('Coverage data not found')
-          message = error.user_friendly_message
-
-          expect(message).to include(
-            'File error: Coverage data not found',
-            'Try one of the following:',
-            'cd to a directory containing coverage/.resultset.json',
-            'Specify a resultset: cov-loupe -r PATH',
-            'Use -h for help: cov-loupe -h'
-          )
-        end
-      end
-
-      it 'does not include helpful tips in MCP mode' do
-        # Create an MCP context
-        error_handler = CovLoupe::ErrorHandlerFactory.for_mcp_server
-        context = CovLoupe.create_context(error_handler: error_handler, mode: :mcp)
-        CovLoupe.with_context(context) do
-          error = described_class.new('Coverage data not found')
-          message = error.user_friendly_message
-
-          expect(message).to eq('File error: Coverage data not found')
-          expect(message).not_to include('Try one of the following:')
-        end
-      end
-    end
-  end
-
-  describe CovLoupe::CoverageDataStaleError do
-    describe 'time formatting edge cases' do
-      it 'handles invalid epoch seconds gracefully in rescue path' do
-        # Create an object that responds to to_i but breaks Time.at
-        bad_timestamp = Object.new
-        def bad_timestamp.to_i
-          raise ArgumentError, "Can't convert"
-        end
-
-        error = described_class.new(
-          'Test error',
-          nil,
-          file_path: 'test.rb',
-          file_mtime: Time.at(1000),
-          cov_timestamp: bad_timestamp,
-          src_len: 10,
-          cov_len: 8
-        )
-
-        message = error.user_friendly_message
-        expect(message).to include('Coverage data stale')
-        expect(message).to include('Test error')
-      end
-
-      it 'handles time that breaks Time.parse but has valid to_s' do
-        # Create an object that can't be parsed but has valid to_s
-        bad_time = Object.new
-        def bad_time.to_s
-          'unparseable_time_string'
-        end
-
-        error = described_class.new(
-          'Test error',
-          nil,
-          file_path: 'test.rb',
-          file_mtime: bad_time,
-          cov_timestamp: 1000,
-          src_len: 10,
-          cov_len: 8
-        )
-
-        message = error.user_friendly_message
-        expect(message).to include('Coverage data stale')
-        expect(message).to include('Test error')
-        # Should fallback to string representation
-        expect(message).to include('unparseable_time_string')
-      end
-
-      it 'handles delta calculation with invalid values in rescue path' do
-        # Create objects that break arithmetic
-        bad_time = Object.new
-        def bad_time.to_i
-          raise ArgumentError, "Can't convert"
-        end
-
-        bad_timestamp = Object.new
-        def bad_timestamp.to_i
-          raise ArgumentError, "Can't convert"
-        end
-
-        error = described_class.new(
-          'Test error',
-          nil,
-          file_path: 'test.rb',
-          file_mtime: bad_time,
-          cov_timestamp: bad_timestamp,
-          src_len: 10,
-          cov_len: 8
-        )
-
-        message = error.user_friendly_message
-        expect(message).to include('Coverage data stale')
-        # Delta line should not appear when calculation fails
-        expect(message).not_to match(/Delta\s+- file is/)
-      end
-    end
-
-    describe 'default message generation' do
-      it 'uses default message when message is nil with file_path' do
-        error = described_class.new(
-          nil, # No message provided - triggers default_message
-          nil,
-          file_path: 'test.rb',
-          file_mtime: Time.at(2000),
-          cov_timestamp: 1000
-        )
-
-        message = error.user_friendly_message
-        # default_message returns "Coverage data appears stale for test.rb"
-        expect(message).to include('Coverage data appears stale for test.rb')
-        # File path should appear in the details section
-        expect(message).to match(/File\s+-/)
-      end
-
-      it 'uses generic default message when file_path is nil' do
-        # This tests the fallback path when file_path is nil: fp = file_path || 'file'
-        error = described_class.new(
-          nil, # No message - triggers default_message
-          nil,
-          file_path: nil, # No file path - triggers 'file' fallback
-          file_mtime: Time.at(2000),
-          cov_timestamp: 1000
-        )
-
-        message = error.user_friendly_message
-        # When file_path is nil, default_message returns "Coverage data appears stale for file"
-        expect(message).to include('Coverage data appears stale for file')
-      end
-    end
-  end
-
-  describe CovLoupe::CoverageDataProjectStaleError do
-    describe 'default message generation' do
-      # These tests exercise the private default_message method
-      it 'includes project stale info when message is nil' do
-        error = described_class.new(
-          nil, # StandardError sets message to class name when nil
-          nil,
-          cov_timestamp: 1000,
-          newer_files: ['file1.rb', 'file2.rb']
-        )
-
-        message = error.user_friendly_message
-        # user_friendly_message prefixes with "Coverage data stale (project):"
-        expect(message).to include('Coverage data stale (project)')
-        expect(message).to include('Newer files')
-      end
-
-      it 'exercises default_message directly via send' do
-        # Directly test the private default_message method for coverage
-        # This is necessary because user_friendly_message uses `message || default_message`
-        # and StandardError sets message to class name when initialized with nil
-        error = described_class.new(
-          'explicit message',
-          nil,
-          cov_timestamp: 1000
-        )
-
-        # Call the private default_message method directly
-        result = error.send(:default_message)
-        expect(result).to eq('Coverage data appears stale for project')
-      end
-    end
-
-    describe 'large file list truncation' do
-      it 'shows all files when there are 10 or fewer deleted files' do
-        deleted_files = (1..10).map { |i| "deleted_file_#{i}.rb" }
-        error = described_class.new(
-          'Test error',
-          nil,
-          cov_timestamp: 1000,
-          deleted_files: deleted_files
-        )
-
-        message = error.user_friendly_message
-        expect(message).to include('Coverage-only files (deleted or moved in project, 10):')
-        deleted_files.each do |file|
-          expect(message).to include("  - #{file}")
-        end
-        expect(message).not_to include('...')
-      end
-
-      it 'truncates and shows ellipsis when there are more than 10 deleted files' do
-        deleted_files = (1..15).map { |i| "deleted_file_#{i}.rb" }
-        error = described_class.new(
-          'Test error',
-          nil,
-          cov_timestamp: 1000,
-          deleted_files: deleted_files
-        )
-
-        message = error.user_friendly_message
-        expect(message).to include('Coverage-only files (deleted or moved in project, 15):')
-        # Should show first 10 files
-        deleted_files[0..9].each do |file|
-          expect(message).to include("  - #{file}")
-        end
-        # Should not show files beyond 10
-        deleted_files[10..14].each do |file|
-          expect(message).not_to include("  - #{file}")
-        end
-        # Should show ellipsis
-        expect(message).to include('...')
-      end
-
-      it 'shows all files when there are 10 or fewer missing files' do
-        missing_files = (1..10).map { |i| "missing_file_#{i}.rb" }
-        error = described_class.new(
-          'Test error',
-          nil,
-          cov_timestamp: 1000,
-          missing_files: missing_files
-        )
-
-        message = error.user_friendly_message
-        expect(message).to include('Missing files (new in project, not in coverage, 10):')
-        missing_files.each do |file|
-          expect(message).to include("  - #{file}")
-        end
-        expect(message).not_to include('...')
-      end
-
-      it 'truncates and shows ellipsis when there are more than 10 missing files' do
-        missing_files = (1..12).map { |i| "missing_file_#{i}.rb" }
-        error = described_class.new(
-          'Test error',
-          nil,
-          cov_timestamp: 1000,
-          missing_files: missing_files
-        )
-
-        message = error.user_friendly_message
-        expect(message).to include('Missing files (new in project, not in coverage, 12):')
-        # Should show first 10 files
-        missing_files[0..9].each do |file|
-          expect(message).to include("  - #{file}")
-        end
-        # Should not show files beyond 10
-        expect(message).not_to include("  - #{missing_files[11]}")
-        # Should show ellipsis
-        expect(message).to include('...')
-      end
-
-      it 'truncates and shows ellipsis when there are more than 10 newer files' do
-        newer_files = (1..20).map { |i| "newer_file_#{i}.rb" }
-        error = described_class.new(
-          'Test error',
-          nil,
-          cov_timestamp: 1000,
-          newer_files: newer_files
-        )
-
-        message = error.user_friendly_message
-        expect(message).to include('Newer files (20):')
-        # Should show first 10 files
-        newer_files[0..9].each do |file|
-          expect(message).to include("  - #{file}")
-        end
-        # Should not show files beyond 10
-        newer_files[10..19].each do |file|
-          expect(message).not_to include("  - #{file}")
-        end
-        # Should show ellipsis
-        expect(message).to include('...')
-      end
-    end
-  end
-end

data/spec/errors_stale_spec.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe CovLoupe::CoverageDataStaleError do
-  it 'formats a detailed, user-friendly message with UTC/local, delta, and resultset' do
-    file_time = Time.at(TEST_FILE_TIMESTAMP) # 1970-01-01T00:16:40Z
-    cov_epoch = VERY_OLD_TIMESTAMP           # 1970-01-01T00:00:00Z
-    err = described_class.new(
-      'Coverage data appears stale for foo.rb',
-      nil,
-      file_path: 'foo.rb',
-      file_mtime: file_time,
-      cov_timestamp: cov_epoch,
-      src_len: 10,
-      cov_len: 8,
-      resultset_path: '/path/to/coverage/.resultset.json'
-    )
-
-    msg = err.user_friendly_message
-
-    expect(msg).to include('Coverage data stale: Coverage data appears stale for foo.rb')
-    expect(msg).to match(/File\s*-\s*time:\s*1970-01-01T00:16:40Z/)
-    expect(msg).to include('(local ') # do not assert exact local tz
-    expect(msg).to match(/Coverage\s*-\s*time:\s*1970-01-01T00:00:00Z/)
-    expect(msg).to match(/lines:\s*10/)
-    expect(msg).to match(/lines:\s*8/)
-    expect(msg).to match(/Delta\s*- file is \+1000s newer than coverage/)
-    expect(msg).to include('Resultset - /path/to/coverage/.resultset.json')
-  end
-
-  it 'handles missing timestamps gracefully' do
-    err = described_class.new(
-      'Coverage data appears stale for bar.rb',
-      nil,
-      file_path: 'bar.rb',
-      file_mtime: nil,
-      cov_timestamp: nil,
-      src_len: 1,
-      cov_len: 0,
-      resultset_path: nil
-    )
-    msg = err.user_friendly_message
-    expect(msg).to include('Coverage data stale: Coverage data appears stale for bar.rb')
-    expect(msg).to match(/File\s*-\s*time:\s*not found.*lines: 1/m)
-    expect(msg).to match(/Coverage\s*-\s*time:\s*not found.*lines: 0/m)
-    expect(msg).not_to include('Delta')
-  end
-
-  it 'uses default message when message is nil' do
-    err = described_class.new(
-      nil,
-      nil,
-      file_path: 'lib/example.rb',
-      file_mtime: Time.now,
-      cov_timestamp: Time.now.to_i - 1000,
-      src_len: 10,
-      cov_len: 8,
-      resultset_path: '/coverage/.resultset.json'
-    )
-
-    msg = err.user_friendly_message
-    expect(msg).to include('Coverage data stale:')
-    expect(msg).to include('Coverage data appears stale for lib/example.rb')
-  end
-
-  it 'uses "file" in default message when file_path is also nil' do
-    err = described_class.new(
-      nil,
-      nil,
-      file_path: nil,
-      file_mtime: nil,
-      cov_timestamp: nil,
-      src_len: 0,
-      cov_len: 0,
-      resultset_path: nil
-    )
-
-    msg = err.user_friendly_message
-    expect(msg).to include('Coverage data stale:')
-    expect(msg).to include('Coverage data appears stale for file')
-  end
-end

data/spec/file_based_mcp_tools_spec.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require_relative 'shared_examples/file_based_mcp_tools'
-
-# Load all the tool classes that will be tested
-require 'cov_loupe/tools/coverage_summary_tool'
-require 'cov_loupe/tools/coverage_raw_tool'
-require 'cov_loupe/tools/uncovered_lines_tool'
-require 'cov_loupe/tools/coverage_detailed_tool'
-
-RSpec.describe 'File-based MCP Tools' do
-  # Test each file-based tool using the shared example with its specific configuration
-  FILE_BASED_TOOL_CONFIGS.each_value do |config|
-    describe config[:tool_class] do
-      it_behaves_like 'a file-based MCP tool', config
-    end
-  end
-
-  # Test that all file-based tools handle the same parameters consistently
-  describe 'parameter consistency' do
-    let(:server_context) { instance_double('ServerContext').as_null_object }
-
-    before do
-      setup_mcp_response_stub
-    end
-
-    it 'all file-based tools accept the same basic parameters' do
-      # Test that all tools can be called with the same parameter signature
-      FILE_BASED_TOOL_CONFIGS.each_value do |config|
-        model = instance_double(CovLoupe::CoverageModel)
-        allow(CovLoupe::CoverageModel).to receive(:new).and_return(model)
-        allow(model).to receive(config[:model_method]).and_return(config[:mock_data])
-        allow(model).to receive(:relativize) { |payload| payload }
-        allow(model).to receive(:staleness_for).and_return(false)
-
-        expect do
-          config[:tool_class].call(
-            path: 'lib/example.rb',
-            root: '.',
-            resultset: 'coverage',
-            server_context: server_context
-          )
-        end.not_to raise_error
-      end
-    end
-
-    it 'all file-based tools return JSON resources with consistent structure' do
-      FILE_BASED_TOOL_CONFIGS.each_value do |config|
-        model = instance_double(CovLoupe::CoverageModel)
-        allow(CovLoupe::CoverageModel).to receive(:new).and_return(model)
-        allow(model).to receive(config[:model_method]).and_return(config[:mock_data])
-        allow(model).to receive(:relativize) { |payload| payload }
-        allow(model).to receive(:staleness_for).and_return(false)
-
-        response = config[:tool_class].call(path: 'lib/foo.rb', server_context: server_context)
-
-        # All should have the same basic MCP text structure
-        expect(response.payload).to be_an(Array)
-        expect(response.payload.first['type']).to eq('text')
-        expect(response.payload.first).to have_key('text')
-
-        # All should return valid JSON
-        expect { JSON.parse(response.payload.first['text']) }.not_to raise_error
-      end
-    end
-  end
-
-  # Performance/behavior comparison tests
-  describe 'cross-tool consistency' do
-    let(:server_context) { instance_double('ServerContext').as_null_object }
-
-    before do
-      setup_mcp_response_stub
-    end
-
-    it 'tools that include summary data return consistent summary format' do
-      summary_tools = FILE_BASED_TOOL_CONFIGS.select do |_, config|
-        config[:expected_keys].include?('summary')
-      end
-
-      summary_tools.each_value do |config|
-        model = instance_double(CovLoupe::CoverageModel)
-        allow(CovLoupe::CoverageModel).to receive(:new).and_return(model)
-        allow(model).to receive(config[:model_method]).and_return(config[:mock_data])
-        allow(model).to receive(:relativize) { |payload| payload }
-        allow(model).to receive(:staleness_for).and_return(false)
-
-        response = config[:tool_class].call(path: 'lib/foo.rb', server_context: server_context)
-        data = JSON.parse(response.payload.first['text'])
-
-        if data.key?('summary')
-          expect(data['summary']).to include('covered', 'total', 'percentage')
-          expect(data['summary']['percentage']).to be_a(Numeric)
-        end
-      end
-    end
-  end
-end

data/spec/help_tool_spec.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'cov_loupe/tools/help_tool'
-
-RSpec.describe CovLoupe::Tools::HelpTool do
-  let(:server_context) { instance_double('ServerContext').as_null_object }
-
-  before do
-    setup_mcp_response_stub
-  end
-
-  it 'returns guidance for each registered tool' do
-    response = described_class.call(server_context: server_context)
-    expect(response.meta).to be_nil
-
-    payload = response.payload.first
-    expect(payload['type']).to eq('text')
-    data = JSON.parse(payload['text'])
-    tool_names = data['tools'].map { |entry| entry['tool'] }
-
-    expect(tool_names).to include('coverage_summary_tool', 'uncovered_lines_tool',
-      'all_files_coverage_tool', 'coverage_totals_tool', 'coverage_table_tool', 'version_tool')
-    expect(data['tools']).to all(include('use_when', 'avoid_when', 'inputs'))
-  end
-end