simplecov-mcp 0.3.0 → 1.0.0

data/spec/constants_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::Constants do
+  describe 'OPTIONS_EXPECTING_ARGUMENT' do
+    subject(:options) { described_class::OPTIONS_EXPECTING_ARGUMENT }
+
+    it 'exists' do
+      expect(options).not_to be_nil
+    end
+
+    it 'is frozen' do
+      expect(options).to be_frozen
+    end
+
+    it 'contains expected CLI options' do
+      expected_options = %w[
+        -r --resultset
+        -R --root
+        -o --sort-order
+        -s --source
+        -c --source-context
+        -S --stale
+        -g --tracked-globs
+        -l --log-file
+        --error-mode
+        --success-predicate
+      ]
+
+      expect(options).to eq(expected_options)
+    end
+
+    it 'contains only strings' do
+      expect(options).to all(be_a(String))
+    end
+
+    it 'contains options that start with dashes' do
+      expect(options).to all(start_with('-'))
+    end
+  end
+
+  describe 'usage by other classes' do
+    it 'is used by ModeDetector' do
+      expect(SimpleCovMcp::ModeDetector::OPTIONS_EXPECTING_ARGUMENT)
+        .to equal(SimpleCovMcp::Constants::OPTIONS_EXPECTING_ARGUMENT)
+    end
+
+    it 'is used by CoverageCLI' do
+      expect(SimpleCovMcp::CoverageCLI::OPTIONS_EXPECTING_ARGUMENT)
+        .to equal(SimpleCovMcp::Constants::OPTIONS_EXPECTING_ARGUMENT)
+    end
+
+    it 'ensures both classes reference the same object' do
+      cli_options = SimpleCovMcp::CoverageCLI::OPTIONS_EXPECTING_ARGUMENT
+      detector_options = SimpleCovMcp::ModeDetector::OPTIONS_EXPECTING_ARGUMENT
+
+      expect(cli_options).to equal(detector_options)
+    end
+  end
+end

data/spec/coverage_table_tool_spec.rb

@@ -1,63 +1,47 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
-require 'simple_cov_mcp/tools/coverage_table_tool'
+require 'simplecov_mcp/tools/coverage_table_tool'
 
 RSpec.describe SimpleCovMcp::Tools::CoverageTableTool do
-  let(:root) { (FIXTURES / 'project1').to_s }
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
   let(:server_context) { instance_double('ServerContext').as_null_object }
 
   before do
-    stub_const('MCP::Tool::Response', Struct.new(:payload))
+    setup_mcp_response_stub
   end
 
   def run_tool(stale: 'off')
-    # Stub the CoverageModel to avoid file system access
-    model = instance_double(SimpleCovMcp::CoverageModel)
-    allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
-    allow(model).to receive(:all_files).and_return([
-      { 'file' => "#{root}/lib/foo.rb", 'percentage' => 100.0, 'covered' => 10, 'total' => 10, 'stale' => false },
-      { 'file' => "#{root}/lib/bar.rb", 'percentage' =>  50.0, 'covered' =>  5, 'total' => 10, 'stale' => true }
-    ])
-
-    response = described_class.call(root: root, stale: stale, server_context: server_context)
-    response.payload.first[:text]
+    # Let real CoverageModel work to test actual format_table behavior
+    described_class.call(root: root, stale: stale,
+      server_context: server_context).payload.first[:text]
   end
 
   it 'returns a formatted table as a string' do
     output = run_tool
 
-    # Contains a header row and at least one data row with expected columns
-    expect(output).to include('File')
-    expect(output).to include('Covered')
-    expect(output).to include('Total')
-    # Staleness column header reads 'Stale'
-    expect(output).to include(' │ Stale │')
-
-    # Should list fixture files from the demo project
-    expect(output).to include('lib/foo.rb')
-    expect(output).to include('lib/bar.rb')
-
-    # Check for table borders
-    expect(output).to include('┌')
-    expect(output).to include('│')
-    expect(output).to include('└')
-
-    # Summary counts line appears after the table
-    expect(output).to include('Files: total 2, ok 1, stale 1')
+    # Contains table structure, headers, and file data
+    expect(output).to include(
+      '┌', '┬', '┐', '│', '├', '┼', '┤', '└', '┴', '┘',
+      'File', 'Covered', 'Total', ' │ Stale │',
+      'lib/foo.rb', 'lib/bar.rb',
+      'Files: total 2, ok 0, stale 2'
+    )
   end
 
-  it 'configures the CLI to enforce stale checking when requested' do
+  it 'configures CLI to enforce stale checking when requested' do
     model = instance_double(SimpleCovMcp::CoverageModel)
     allow(model).to receive(:all_files).and_return([
       { 'file' => "#{root}/lib/foo.rb", 'percentage' => 100.0, 'covered' => 10, 'total' => 10, 'stale' => false }
     ])
+    allow(model).to receive(:relativize) { |payload| payload }
     expect(SimpleCovMcp::CoverageModel).to receive(:new).with(
       root: root,
       resultset: nil,
-      staleness: 'error',
+      staleness: :error,
       tracked_globs: nil
     ).and_return(model)
+    allow(model).to receive(:format_table).and_return('Mock table output')
 
     described_class.call(root: root, stale: 'error', server_context: server_context)
   end

data/spec/error_handler_spec.rb

@@ -6,18 +6,21 @@ RSpec.describe SimpleCovMcp::ErrorHandler do
   let(:logger) do
     Class.new do
       attr_reader :messages
+
       def initialize; @messages = []; end
       def error(msg); @messages << msg; end
     end.new
   end
 
-  subject(:handler) { described_class.new(log_errors: true, show_stack_traces: false, logger: logger) }
+  subject(:handler) { described_class.new(error_mode: :on, logger: logger) }
 
   it 'maps filesystem errors to friendly custom errors' do
     e = handler.convert_standard_error(Errno::EISDIR.new('Is a directory @ rb_sysopen - a_dir'))
     expect(e).to be_a(SimpleCovMcp::NotAFileError)
 
-    e = handler.convert_standard_error(Errno::ENOENT.new('No such file or directory @ rb_sysopen - missing.txt'))
+    e = handler.convert_standard_error(
+      Errno::ENOENT.new('No such file or directory @ rb_sysopen - missing.txt')
+    )
     expect(e).to be_a(SimpleCovMcp::FileNotFoundError)
 
     e = handler.convert_standard_error(Errno::EACCES.new('Permission denied @ rb_sysopen - secret'))
@@ -31,7 +34,9 @@ RSpec.describe SimpleCovMcp::ErrorHandler do
   end
 
   it 'maps ArgumentError by message' do
-    e = handler.convert_standard_error(ArgumentError.new('wrong number of arguments (given 1, expected 2)'))
+    e = handler.convert_standard_error(
+      ArgumentError.new('wrong number of arguments (given 1, expected 2)')
+    )
     expect(e).to be_a(SimpleCovMcp::UsageError)
 
     e = handler.convert_standard_error(ArgumentError.new('invalid option'))
@@ -39,34 +44,38 @@ RSpec.describe SimpleCovMcp::ErrorHandler do
   end
 
   it 'maps NoMethodError to CoverageDataError with helpful info' do
-    e = handler.convert_standard_error(NoMethodError.new("undefined method `fetch' for #<Hash:0x123>"))
+    e = handler.convert_standard_error(
+      NoMethodError.new("undefined method `fetch' for #<Hash:0x123>")
+    )
     expect(e).to be_a(SimpleCovMcp::CoverageDataError)
     expect(e.user_friendly_message).to include('Invalid coverage data structure')
   end
 
   it 'maps runtime strings from util to friendly errors' do
-    e = handler.convert_standard_error(RuntimeError.new('No coverage entry found for /tmp/foo.rb'))
-    expect(e).to be_a(SimpleCovMcp::FileError)
-    expect(e.user_friendly_message).to include('No coverage data found for file')
-
-    e = handler.convert_standard_error(RuntimeError.new('Could not find .resultset.json under /path; run tests'))
+    e = handler.convert_standard_error(
+      RuntimeError.new('Could not find .resultset.json under /path; run tests')
+    )
     expect(e).to be_a(SimpleCovMcp::CoverageDataError)
     expect(e.user_friendly_message).to include('run your tests first')
 
-    e = handler.convert_standard_error(RuntimeError.new('No .resultset.json found in directory: /path'))
+    e = handler.convert_standard_error(
+      RuntimeError.new('No .resultset.json found in directory: /path')
+    )
     expect(e).to be_a(SimpleCovMcp::CoverageDataError)
 
-    e = handler.convert_standard_error(RuntimeError.new('Specified resultset not found: /nowhere/file.json'))
+    e = handler.convert_standard_error(
+      RuntimeError.new('Specified resultset not found: /nowhere/file.json')
+    )
     expect(e).to be_a(SimpleCovMcp::ResultsetNotFoundError)
   end
 
   it 'logs via provided logger' do
     begin
-      handler.handle_error(Errno::ENOENT.new('No such file or directory @ rb_sysopen - x'), context: 'test', reraise: false)
+      handler.handle_error(Errno::ENOENT.new('No such file or directory @ rb_sysopen - x'),
+        context: 'test', reraise: false)
     rescue StandardError
       # reraise disabled
     end
     expect(logger.messages.join).to include('Error in test')
   end
 end
-

data/spec/error_mode_spec.rb

@@ -0,0 +1,143 @@
+# 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 = []; end
+      def error(msg); @messages << msg; end
+    end.new
+  end
+
+  let(:test_error) { StandardError.new('Test error message') }
+
+  describe 'ErrorHandler error modes' do
+    context 'with error_mode: :off' do
+      subject(:handler) { SimpleCovMcp::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: :on' do
+      subject(:handler) { SimpleCovMcp::ErrorHandler.new(error_mode: :on, 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: :trace' do
+      subject(:handler) { SimpleCovMcp::ErrorHandler.new(error_mode: :trace, 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 StandardError => 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 = SimpleCovMcp::ErrorHandlerFactory.for_cli(error_mode: :trace)
+      expect(cli_handler.error_mode).to eq(:trace)
+
+      lib_handler = SimpleCovMcp::ErrorHandlerFactory.for_library(error_mode: :off)
+      expect(lib_handler.error_mode).to eq(:off)
+
+      mcp_handler = SimpleCovMcp::ErrorHandlerFactory.for_mcp_server(error_mode: :on)
+      expect(mcp_handler.error_mode).to eq(:on)
+    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, :on, :trace].each do |mode|
+        expect(SimpleCovMcp::ErrorHandlerFactory)
+          .to receive(:for_mcp_server).with(error_mode: mode).and_call_original
+
+        response = SimpleCovMcp::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 = SimpleCovMcp::CoverageCLI.new
+
+      # Test that the option parser accepts the flag
+      expect do
+        cli.send(:parse_options!, ['--error-mode', 'trace', 'summary', 'lib/foo.rb'])
+      end.not_to raise_error
+
+      expect(cli.config.error_mode).to eq(:trace)
+    end
+
+    it 'creates error handler with specified mode' do
+      cli = SimpleCovMcp::CoverageCLI.new
+      cli.send(:parse_options!, ['--error-mode', 'off', 'summary', 'lib/foo.rb'])
+
+      # Trigger error handler creation
+      cli.send(:ensure_error_handler)
+
+      error_handler = cli.instance_variable_get(:@error_handler)
+      expect(error_handler.error_mode).to eq(:off)
+    end
+
+    it 'validates error mode values' do
+      cli = SimpleCovMcp::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
+        SimpleCovMcp::ErrorHandler.new(error_mode: :invalid)
+      end.to raise_error(ArgumentError, /Invalid error_mode: :invalid/)
+    end
+
+    it 'accepts all valid error modes' do
+      expect { SimpleCovMcp::ErrorHandler.new(error_mode: :off) }.not_to raise_error
+      expect { SimpleCovMcp::ErrorHandler.new(error_mode: :on) }.not_to raise_error
+      expect { SimpleCovMcp::ErrorHandler.new(error_mode: :trace) }.not_to raise_error
+    end
+  end
+end

data/spec/errors_edge_cases_spec.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'SimpleCovMcp error edge cases' do
+  describe SimpleCovMcp::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 = SimpleCovMcp::CoverageDataStaleError.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 = SimpleCovMcp::CoverageDataStaleError.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 = SimpleCovMcp::CoverageDataStaleError.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' do
+        error = SimpleCovMcp::CoverageDataStaleError.new(
+          nil, # No message provided
+          nil,
+          file_path: 'test.rb',
+          file_mtime: Time.at(2000),
+          cov_timestamp: 1000
+        )
+
+        message = error.user_friendly_message
+        # When message is nil, the error class name is used by StandardError
+        # which then triggers default_message to be called
+        expect(message).to include('Coverage data')
+        expect(message).to include('stale')
+        # 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
+        error = SimpleCovMcp::CoverageDataStaleError.new(
+          nil, # No message
+          nil,
+          file_path: nil, # No file path
+          file_mtime: Time.at(2000),
+          cov_timestamp: 1000
+        )
+
+        message = error.user_friendly_message
+        # When file_path is nil, should use 'file' as fallback
+        expect(message).to include('Coverage data')
+        expect(message).to include('file')
+      end
+    end
+  end
+
+  describe SimpleCovMcp::CoverageDataProjectStaleError do
+    describe 'default message generation' do
+      it 'uses default message when message is nil' do
+        error = SimpleCovMcp::CoverageDataProjectStaleError.new(
+          nil, # No message provided
+          nil,
+          cov_timestamp: 1000,
+          newer_files: ['file1.rb', 'file2.rb']
+        )
+
+        message = error.user_friendly_message
+        # When message is nil, StandardError uses class name, then default_message is called
+        expect(message).to include('Coverage data')
+        expect(message).to include('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 = SimpleCovMcp::CoverageDataProjectStaleError.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 = SimpleCovMcp::CoverageDataProjectStaleError.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 = SimpleCovMcp::CoverageDataProjectStaleError.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 = SimpleCovMcp::CoverageDataProjectStaleError.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 = SimpleCovMcp::CoverageDataProjectStaleError.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

@@ -4,8 +4,8 @@ require 'spec_helper'
 
 RSpec.describe SimpleCovMcp::CoverageDataStaleError do
   it 'formats a detailed, user-friendly message with UTC/local, delta, and resultset' do
-    file_time = Time.at(1_000) # 1970-01-01T00:16:40Z
-    cov_epoch = 0              # 1970-01-01T00:00:00Z
+    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,