cov-loupe 3.0.0

data/spec/errors_edge_cases_spec.rb

@@ -0,0 +1,312 @@
+# 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

@@ -0,0 +1,83 @@
+# 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

@@ -0,0 +1,99 @@
+# 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/fixtures/project1/lib/bar.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+puts 'bar line 1 (uncovered)'
+puts 'bar line 2 (uncovered)'
+puts 'bar line 3'

data/spec/fixtures/project1/lib/foo.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+puts 'foo line 1'
+puts 'foo line 2 (uncovered)'
+
+puts 'foo line 4'

data/spec/help_tool_spec.rb

@@ -0,0 +1,26 @@
+# 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