simplecov-mcp 1.0.1 → 2.0.1

data/spec/error_mode_spec.rb

@@ -7,8 +7,8 @@ RSpec.describe 'Error Mode System' do
     Class.new do
       attr_reader :messages
 
-      def initialize; @messages = []; end
-      def error(msg); @messages << msg; end
+      def initialize = @messages = []
+      def error(msg) = @messages << msg
     end.new
   end
 
@@ -27,8 +27,8 @@ RSpec.describe 'Error Mode System' do
       end
     end
 
-    context 'with error_mode: :on' do
-      subject(:handler) { SimpleCovMcp::ErrorHandler.new(error_mode: :on, logger: test_logger) }
+    context 'with error_mode: :log' do
+      subject(:handler) { SimpleCovMcp::ErrorHandler.new(error_mode: :log, logger: test_logger) }
 
       it 'logs errors but not stack traces' do
         expect(handler.log_errors?).to be true
@@ -41,8 +41,8 @@ RSpec.describe 'Error Mode System' do
       end
     end
 
-    context 'with error_mode: :trace' do
-      subject(:handler) { SimpleCovMcp::ErrorHandler.new(error_mode: :trace, logger: test_logger) }
+    context 'with error_mode: :debug' do
+      subject(:handler) { SimpleCovMcp::ErrorHandler.new(error_mode: :debug, logger: test_logger) }
 
       it 'logs errors with stack traces' do
         expect(handler.log_errors?).to be true
@@ -51,7 +51,7 @@ RSpec.describe 'Error Mode System' do
         # Create an error with a proper backtrace
         begin
           raise StandardError, 'Test error message'
-        rescue StandardError => e
+        rescue => e
           handler.handle_error(e, context: 'test', reraise: false)
         end
 
@@ -64,14 +64,14 @@ RSpec.describe 'Error Mode System' do
 
   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)
+      cli_handler = SimpleCovMcp::ErrorHandlerFactory.for_cli(error_mode: :debug)
+      expect(cli_handler.error_mode).to eq(:debug)
 
       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)
+      mcp_handler = SimpleCovMcp::ErrorHandlerFactory.for_mcp_server(error_mode: :log)
+      expect(mcp_handler.error_mode).to eq(:log)
     end
   end
 
@@ -82,13 +82,13 @@ RSpec.describe 'Error Mode System' do
       test_error = StandardError.new('Test MCP error')
 
       # Test different error modes
-      [:off, :on, :trace].each do |mode|
+      [:off, :log, :debug].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:')
+        expect(response.payload.first['text']).to include('Error:')
       end
     end
   end
@@ -101,21 +101,17 @@ RSpec.describe 'Error Mode System' do
 
       # Test that the option parser accepts the flag
       expect do
-        cli.send(:parse_options!, ['--error-mode', 'trace', 'summary', 'lib/foo.rb'])
+        cli.send(:parse_options!, ['--error-mode', 'debug', 'summary', 'lib/foo.rb'])
       end.not_to raise_error
 
-      expect(cli.config.error_mode).to eq(:trace)
+      expect(cli.config.error_mode).to eq(:debug)
     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)
+      expect(cli.send(:error_handler).error_mode).to eq(:off)
     end
 
     it 'validates error mode values' do
@@ -136,8 +132,8 @@ RSpec.describe 'Error Mode System' do
 
     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
+      expect { SimpleCovMcp::ErrorHandler.new(error_mode: :log) }.not_to raise_error
+      expect { SimpleCovMcp::ErrorHandler.new(error_mode: :debug) }.not_to raise_error
     end
   end
 end

data/spec/errors_edge_cases_spec.rb

@@ -2,7 +2,66 @@
 
 require 'spec_helper'
 
-RSpec.describe 'SimpleCovMcp error edge cases' do
+RSpec.describe SimpleCovMcp do
+  describe SimpleCovMcp::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: SimpleCovMcp::ConfigurationError')
+      end
+    end
+  end
+
+
+  describe SimpleCovMcp::ResultsetNotFoundError do
+    describe '#user_friendly_message' do
+      it 'includes helpful tips in CLI mode' do
+        # Create a CLI context (not MCP mode)
+        error_handler = SimpleCovMcp::ErrorHandlerFactory.for_cli
+        context = SimpleCovMcp.create_context(error_handler: error_handler, mode: :cli)
+        SimpleCovMcp.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: simplecov-mcp -r PATH',
+            'Use -h for help: simplecov-mcp -h'
+          )
+        end
+      end
+
+      it 'does not include helpful tips in MCP mode' do
+        # Create an MCP context
+        error_handler = SimpleCovMcp::ErrorHandlerFactory.for_mcp_server
+        context = SimpleCovMcp.create_context(error_handler: error_handler, mode: :mcp)
+        SimpleCovMcp.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 SimpleCovMcp::CoverageDataStaleError do
     describe 'time formatting edge cases' do
       it 'handles invalid epoch seconds gracefully in rescue path' do
@@ -12,7 +71,7 @@ RSpec.describe 'SimpleCovMcp error edge cases' do
           raise ArgumentError, "Can't convert"
         end
 
-        error = SimpleCovMcp::CoverageDataStaleError.new(
+        error = described_class.new(
           'Test error',
           nil,
           file_path: 'test.rb',
@@ -34,7 +93,7 @@ RSpec.describe 'SimpleCovMcp error edge cases' do
           'unparseable_time_string'
         end
 
-        error = SimpleCovMcp::CoverageDataStaleError.new(
+        error = described_class.new(
           'Test error',
           nil,
           file_path: 'test.rb',
@@ -63,7 +122,7 @@ RSpec.describe 'SimpleCovMcp error edge cases' do
           raise ArgumentError, "Can't convert"
         end
 
-        error = SimpleCovMcp::CoverageDataStaleError.new(
+        error = described_class.new(
           'Test error',
           nil,
           file_path: 'test.rb',
@@ -81,9 +140,9 @@ RSpec.describe 'SimpleCovMcp error edge cases' do
     end
 
     describe 'default message generation' do
-      it 'uses default message when message is nil' do
-        error = SimpleCovMcp::CoverageDataStaleError.new(
-          nil, # No message provided
+      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),
@@ -91,52 +150,66 @@ RSpec.describe 'SimpleCovMcp error edge cases' do
         )
 
         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')
+        # 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
-        error = SimpleCovMcp::CoverageDataStaleError.new(
-          nil, # No message
+        # 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
+          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, should use 'file' as fallback
-        expect(message).to include('Coverage data')
-        expect(message).to include('file')
+        # 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 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
+      # 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
-        # When message is nil, StandardError uses class name, then default_message is called
-        expect(message).to include('Coverage data')
-        expect(message).to include('project')
+        # 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 = SimpleCovMcp::CoverageDataProjectStaleError.new(
+        error = described_class.new(
           'Test error',
           nil,
           cov_timestamp: 1000,
@@ -153,7 +226,7 @@ RSpec.describe 'SimpleCovMcp error edge cases' do
 
       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(
+        error = described_class.new(
           'Test error',
           nil,
           cov_timestamp: 1000,
@@ -176,7 +249,7 @@ RSpec.describe 'SimpleCovMcp error edge cases' do
 
       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(
+        error = described_class.new(
           'Test error',
           nil,
           cov_timestamp: 1000,
@@ -193,7 +266,7 @@ RSpec.describe 'SimpleCovMcp error edge cases' do
 
       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(
+        error = described_class.new(
           'Test error',
           nil,
           cov_timestamp: 1000,
@@ -214,7 +287,7 @@ RSpec.describe 'SimpleCovMcp error edge cases' do
 
       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(
+        error = described_class.new(
           'Test error',
           nil,
           cov_timestamp: 1000,

data/spec/errors_stale_spec.rb

@@ -46,4 +46,38 @@ RSpec.describe SimpleCovMcp::CoverageDataStaleError do
     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

@@ -11,7 +11,7 @@ require 'simplecov_mcp/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 do |tool_name, config|
+  FILE_BASED_TOOL_CONFIGS.each_value do |config|
     describe config[:tool_class] do
       it_behaves_like 'a file-based MCP tool', config
     end
@@ -27,7 +27,7 @@ RSpec.describe 'File-based MCP Tools' do
 
     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 do |tool_name, config|
+      FILE_BASED_TOOL_CONFIGS.each_value do |config|
         model = instance_double(SimpleCovMcp::CoverageModel)
         allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
         allow(model).to receive(config[:model_method]).and_return(config[:mock_data])
@@ -46,7 +46,7 @@ RSpec.describe 'File-based MCP Tools' do
     end
 
     it 'all file-based tools return JSON resources with consistent structure' do
-      FILE_BASED_TOOL_CONFIGS.each do |tool_name, config|
+      FILE_BASED_TOOL_CONFIGS.each_value do |config|
         model = instance_double(SimpleCovMcp::CoverageModel)
         allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
         allow(model).to receive(config[:model_method]).and_return(config[:mock_data])
@@ -79,7 +79,7 @@ RSpec.describe 'File-based MCP Tools' do
         config[:expected_keys].include?('summary')
       end
 
-      summary_tools.each do |tool_name, config|
+      summary_tools.each_value do |config|
         model = instance_double(SimpleCovMcp::CoverageModel)
         allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
         allow(model).to receive(config[:model_method]).and_return(config[:mock_data])
@@ -90,8 +90,8 @@ RSpec.describe 'File-based MCP Tools' do
         data = JSON.parse(response.payload.first['text'])
 
         if data.key?('summary')
-          expect(data['summary']).to include('covered', 'total', 'pct')
-          expect(data['summary']['pct']).to be_a(Numeric)
+          expect(data['summary']).to include('covered', 'total', 'percentage')
+          expect(data['summary']['percentage']).to be_a(Numeric)
         end
       end
     end

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

@@ -1,3 +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

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

data/spec/help_tool_spec.rb

@@ -20,23 +20,7 @@ RSpec.describe SimpleCovMcp::Tools::HelpTool do
     tool_names = data['tools'].map { |entry| entry['tool'] }
 
     expect(tool_names).to include('coverage_summary_tool', 'uncovered_lines_tool',
-      'all_files_coverage_tool', 'coverage_table_tool', 'version_tool')
-    expect(data['tools']).to all(include('use_when', 'avoid_when', 'inputs', 'example'))
-  end
-
-  it 'filters entries when a query is provided' do
-    response = described_class.call(query: 'uncovered', server_context: server_context)
-    payload = response.payload.first
-    expect(payload['type']).to eq('text')
-    data = JSON.parse(payload['text'])
-
-    expect(data['tools']).not_to be_empty
-    expect(data['tools']).to all(satisfy do |entry|
-      combined =
-        [entry['tool'], entry['label'], entry['use_when'], entry['avoid_when']]
-        .compact.join(' ').downcase
-      combined.include?('uncovered')
-    end)
-    expect(data['tools'].map { |entry| entry['tool'] }).to include('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