simplecov-mcp 1.0.1 → 2.0.0

data/spec/mode_detector_spec.rb

@@ -2,37 +2,47 @@
 
 require 'spec_helper'
 
+# Array-driven test cases for comprehensive coverage
+# Format: [argv, tty?, expected_result, description]
+CLI_MODE_SCENARIOS = [
+  # Priority 1: --force-cli flag (highest priority)
+  [['--force-cli'], false, true, '--force-cli with piped input'],
+  [['--force-cli', '--format', 'json'], false, true, '--force-cli with other flags'],
+
+  # Priority 2: Valid subcommands (must be first arg)
+  [['list'], false, true, 'list subcommand'],
+  [['summary', 'lib/foo.rb'], false, true, 'summary with path'],
+  [['version'], false, true, 'version subcommand'],
+  [['total'], false, true, 'total subcommand'],
+  [['list', '--format', 'json'], false, true, 'subcommand with trailing flags'],
+
+  # Priority 3: Invalid subcommand attempts (must be first non-flag arg)
+  [['invalid-command'], false, true, 'invalid subcommand (shows error)'],
+  [['lib/foo.rb'], false, true, 'file path (shows error)'],
+
+  # Priority 4: TTY determines mode when no subcommand/force-cli
+  [[], true, true, 'empty args with TTY'],
+  [[], false, false, 'empty args with piped input'],
+  [['--format', 'json'], true, true, 'flags only with TTY'],
+  [['--format', 'json'], false, false, 'flags only with piped input'],
+  [['-r', 'foo', '--format', 'json'], false, false, 'multiple flags with piped input'],
+
+  # Edge cases: flags before subcommands should now be detected as CLI mode
+  [['--format', 'json', 'list'], false, true, 'flag first = CLI mode'],
+  [['-r', 'foo', 'summary'], false, true, 'option first = CLI mode'],
+].freeze
+
+# Simpler test cases for the inverse method
+MCP_SCENARIOS = [
+  [[], false, true, 'piped input, no args'],
+  [['--format', 'json'], false, true, 'piped input with flags'],
+  [[], true, false, 'TTY, no args'],
+  [['--force-cli'], false, false, '--force-cli flag'],
+  [['list'], false, false, 'subcommand'],
+].freeze
+
 RSpec.describe SimpleCovMcp::ModeDetector do
   describe '.cli_mode?' do
-    # Array-driven test cases for comprehensive coverage
-    # Format: [argv, tty?, expected_result, description]
-    CLI_MODE_SCENARIOS = [
-      # Priority 1: --force-cli flag (highest priority)
-      [['--force-cli'], false, true, '--force-cli with piped input'],
-      [['--force-cli', '--json'], false, true, '--force-cli with other flags'],
-
-      # Priority 2: Valid subcommands (must be first arg)
-      [['list'], false, true, 'list subcommand'],
-      [['summary', 'lib/foo.rb'], false, true, 'summary with path'],
-      [['version'], false, true, 'version subcommand'],
-      [['list', '--json'], false, true, 'subcommand with trailing flags'],
-
-      # Priority 3: Invalid subcommand attempts (must be first non-flag arg)
-      [['invalid-command'], false, true, 'invalid subcommand (shows error)'],
-      [['lib/foo.rb'], false, true, 'file path (shows error)'],
-
-      # Priority 4: TTY determines mode when no subcommand/force-cli
-      [[], true, true, 'empty args with TTY'],
-      [[], false, false, 'empty args with piped input'],
-      [['--json'], true, true, 'flags only with TTY'],
-      [['--json'], false, false, 'flags only with piped input'],
-      [['-r', 'foo', '--json'], false, false, 'multiple flags with piped input'],
-
-      # Edge cases: flags before subcommands should now be detected as CLI mode
-      [['--json', 'list'], false, true, 'flag first = CLI mode'],
-      [['-r', 'foo', 'summary'], false, true, 'option first = CLI mode'],
-    ].freeze
-
     CLI_MODE_SCENARIOS.each do |argv, is_tty, expected, description|
       it "#{expected ? 'CLI' : 'MCP'}: #{description}" do
         stdin = double('stdin', tty?: is_tty)
@@ -53,21 +63,12 @@ RSpec.describe SimpleCovMcp::ModeDetector do
     end
 
     it 'uses STDIN by default when no stdin parameter given' do
-      allow(STDIN).to receive(:tty?).and_return(true)
+      allow($stdin).to receive(:tty?).and_return(true)
       expect(described_class.cli_mode?([])).to be true
     end
   end
 
   describe '.mcp_server_mode?' do
-    # Simpler test cases for the inverse method
-    MCP_SCENARIOS = [
-      [[], false, true, 'piped input, no args'],
-      [['--json'], false, true, 'piped input with flags'],
-      [[], true, false, 'TTY, no args'],
-      [['--force-cli'], false, false, '--force-cli flag'],
-      [['list'], false, false, 'subcommand'],
-    ].freeze
-
     MCP_SCENARIOS.each do |argv, is_tty, expected, description|
       it "#{expected ? 'MCP' : 'CLI'}: #{description}" do
         stdin = double('stdin', tty?: is_tty)
@@ -137,12 +138,16 @@ RSpec.describe SimpleCovMcp::ModeDetector do
       expect(described_class.cli_mode?(['--version'], stdin: stdin)).to be true
     end
 
+    it 'chooses CLI mode for -v' do
+      expect(described_class.cli_mode?(['-v'], stdin: stdin)).to be true
+    end
+
     it 'chooses CLI mode for --json list' do
-      expect(described_class.cli_mode?(['--json', 'list'], stdin: stdin)).to be true
+      expect(described_class.cli_mode?(['--format', 'json', 'list'], stdin: stdin)).to be true
     end
 
     it 'chooses MCP mode for flags without a subcommand' do
-      expect(described_class.cli_mode?(['--json'], stdin: stdin)).to be false
+      expect(described_class.cli_mode?(['--format', 'json'], stdin: stdin)).to be false
     end
   end
 end

data/spec/model_error_handling_spec.rb

@@ -4,14 +4,40 @@ require 'spec_helper'
 
 RSpec.describe SimpleCovMcp::CoverageModel, 'error handling' do
   let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:malformed_resultset) do
+    {
+      'RSpec' => {
+        'coverage' => 'not_a_hash' # Should be a hash, not a string
+      }
+    }
+  end
 
   describe 'initialization error handling' do
+    let(:valid_resultset) do
+      {
+        'RSpec' => {
+          'coverage' => {
+            "lib/foo\x00bar.rb" => { 'lines' => [1, 0, 1] } # Path with NULL byte
+          }
+        },
+        'timestamp' => 1000
+      }
+    end
+    let(:malformed_resultset) do
+      {
+        'RSpec' => {
+          'coverage' => 'not_a_hash' # Should be a hash, not a string
+        }
+      }
+    end
+
     it 'raises CoverageDataError with message detail for invalid JSON format' do
       # Mock JSON.parse to raise JSON::ParserError
-      allow(JSON).to receive(:parse).and_raise(JSON::ParserError.new('unexpected token'))
+      allow(JSON).to receive(:load_file).with(anything)
+        .and_raise(JSON::ParserError.new('unexpected token'))
 
       expect do
-        SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
+        described_class.new(root: root, resultset: 'coverage')
       end.to raise_error(SimpleCovMcp::CoverageDataError) do |error|
         expect(error.message).to include('Invalid coverage data format')
         expect(error.message).to include('unexpected token')
@@ -20,33 +46,24 @@ RSpec.describe SimpleCovMcp::CoverageModel, 'error handling' do
 
     it 'raises FilePermissionError when coverage file is not readable' do
       # Mock File.read to raise Errno::EACCES
-      allow(File).to receive(:read).and_call_original
-      allow(File).to receive(:read).with(end_with('.resultset.json')).and_raise(
+      allow(JSON).to receive(:load_file).with(anything).and_raise(
         Errno::EACCES.new('Permission denied')
       )
 
       expect do
-        SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
+        described_class.new(root: root, resultset: 'coverage')
       end.to raise_error(SimpleCovMcp::FilePermissionError) do |error|
         expect(error.message).to include('Permission denied reading coverage data')
         expect(error.message).to include('Permission denied')
       end
     end
 
-    it 'raises CoverageDataError when resultset structure is invalid (TypeError)' do
-      # Create a malformed resultset that will cause TypeError
-      malformed_resultset = {
-        'RSpec' => {
-          'coverage' => 'not_a_hash' # Should be a hash, not a string
-        }
-      }
 
-      allow(File).to receive(:read).and_call_original
-      allow(File).to receive(:read).with(end_with('.resultset.json'))
-        .and_return(malformed_resultset.to_json)
+    it 'raises CoverageDataError when resultset structure is invalid (TypeError)' do
+      allow(JSON).to receive(:load_file).with(anything).and_return(malformed_resultset)
 
       expect do
-        SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
+        described_class.new(root: root, resultset: 'coverage')
       end.to raise_error(SimpleCovMcp::CoverageDataError) do |error|
         expect(error.message).to include('Invalid coverage data structure')
       end
@@ -62,36 +79,31 @@ RSpec.describe SimpleCovMcp::CoverageModel, 'error handling' do
         }
       }
 
-      allow(File).to receive(:read).and_call_original
-      allow(File).to receive(:read).with(end_with('.resultset.json'))
-        .and_return(malformed_resultset.to_json)
+      allow(File).to receive(:open).and_call_original
+      allow(File).to receive(:open).with(end_with('.resultset.json'), 'r')
+        .and_return(StringIO.new(malformed_resultset.to_json))
 
-      # This might succeed or fail depending on how the code handles it
-      # Let's make it fail by mocking transform_keys to raise NoMethodError
-      allow_any_instance_of(Hash).to receive(:transform_keys)
+      broken_map = instance_double('CoverageMap')
+      allow(broken_map).to receive(:transform_keys)
         .and_raise(NoMethodError.new("undefined method `upcase' for nil:NilClass"))
+      allow(SimpleCovMcp::ResultsetLoader).to receive(:load).and_return(
+        SimpleCovMcp::ResultsetLoader::Result.new(coverage_map: broken_map,
+          timestamp: 0, suite_names: ['RSpec'])
+      )
 
       expect do
-        SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
+        described_class.new(root: root, resultset: 'coverage')
       end.to raise_error(SimpleCovMcp::CoverageDataError) do |error|
         expect(error.message).to include('Invalid coverage data structure')
       end
     end
 
-    it 'raises CoverageDataError when path operations raise ArgumentError' do
-      # Create a valid resultset structure with a problematic path
-      valid_resultset = {
-        'RSpec' => {
-          'coverage' => {
-            "lib/foo\x00bar.rb" => { 'lines' => [1, 0, 1] } # Path with NULL byte
-          },
-          'timestamp' => 1000
-        }
-      }
 
-      allow(File).to receive(:read).and_call_original
-      allow(File).to receive(:read).with(end_with('.resultset.json'))
-        .and_return(valid_resultset.to_json)
+
+
+    it 'raises CoverageDataError when path operations raise ArgumentError' do
+      allow(JSON).to receive(:load_file).with(end_with('.resultset.json'))
+        .and_return(valid_resultset)
 
       # Mock File.absolute_path to raise ArgumentError when called with the problematic path
       # But allow it to work for the root initialization
@@ -101,7 +113,7 @@ RSpec.describe SimpleCovMcp::CoverageModel, 'error handling' do
       )
 
       expect do
-        SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
+        described_class.new(root: root, resultset: 'coverage')
       end.to raise_error(SimpleCovMcp::CoverageDataError) do |error|
         expect(error.message).to include('Invalid path in coverage data')
         expect(error.message).to include('null byte')
@@ -109,13 +121,12 @@ RSpec.describe SimpleCovMcp::CoverageModel, 'error handling' do
     end
 
     it 'preserves error context in JSON::ParserError messages' do
-      # Mock JSON.parse to raise JSON::ParserError with specific message
-      allow(JSON).to receive(:parse).and_raise(
+      allow(JSON).to receive(:load_file).with(anything).and_raise(
         JSON::ParserError.new('765: unexpected token at line 3, column 5')
       )
 
       expect do
-        SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
+        described_class.new(root: root, resultset: 'coverage')
       end.to raise_error(SimpleCovMcp::CoverageDataError) do |error|
         # Verify the original error message details are preserved
         expect(error.message).to include('765')
@@ -126,13 +137,12 @@ RSpec.describe SimpleCovMcp::CoverageModel, 'error handling' do
     it 'provides helpful error for permission issues with file path' do
       # Mock to raise permission error with actual file path
       resultset_path = File.join(root, 'coverage', '.resultset.json')
-      allow(File).to receive(:read).and_call_original
-      allow(File).to receive(:read).with(resultset_path).and_raise(
+      allow(JSON).to receive(:load_file).with(resultset_path).and_raise(
         Errno::EACCES.new(resultset_path)
       )
 
       expect do
-        SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
+        described_class.new(root: root, resultset: 'coverage')
       end.to raise_error(SimpleCovMcp::FilePermissionError) do |error|
         expect(error.message).to include('Permission denied')
         expect(error.message).to match(/\.resultset\.json/)
@@ -141,39 +151,37 @@ RSpec.describe SimpleCovMcp::CoverageModel, 'error handling' do
   end
 
   describe 'error context preservation' do
-    it 'includes original exception message in all specific error types' do
-      test_cases = [
-        {
-          error_class: JSON::ParserError,
-          message: 'unexpected character at byte 42',
-          expected_type: SimpleCovMcp::CoverageDataError,
-          expected_content: 'unexpected character at byte 42'
-        },
-        {
-          error_class: Errno::EACCES,
-          message: '/path/to/coverage/.resultset.json',
-          expected_type: SimpleCovMcp::FilePermissionError,
-          expected_content: '/path/to/coverage/.resultset.json'
-        },
-        {
-          error_class: TypeError,
-          message: 'no implicit conversion of String into Integer',
-          expected_type: SimpleCovMcp::CoverageDataError,
-          expected_content: 'no implicit conversion'
-        }
-      ]
-
-      test_cases.each do |test_case|
-        allow(File).to receive(:read).and_call_original
-        allow(File).to receive(:read).with(end_with('.resultset.json')).and_raise(
-          test_case[:error_class].new(test_case[:message])
-        )
-
-        expect do
-          SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
-        end.to raise_error(test_case[:expected_type]) do |error|
-          expect(error.message).to include(test_case[:expected_content])
-        end
+    it 'includes original exception message for JSON::ParserError' do
+      allow(JSON).to receive(:load_file).with(anything)
+        .and_raise(JSON::ParserError.new('unexpected character at byte 42'))
+
+      expect do
+        described_class.new(root: root, resultset: 'coverage')
+      end.to raise_error(SimpleCovMcp::CoverageDataError) do |error|
+        expect(error.message).to include('unexpected character at byte 42')
+      end
+    end
+
+    it 'includes original exception message for Errno::EACCES' do
+      resultset_path = File.join(root, 'coverage', '.resultset.json')
+      allow(JSON).to receive(:load_file).with(resultset_path).and_raise(Errno::EACCES.new(resultset_path))
+
+      expect do
+        described_class.new(root: root, resultset: 'coverage')
+      end.to raise_error(SimpleCovMcp::FilePermissionError) do |error|
+        expect(error.message).to include(resultset_path)
+      end
+    end
+
+    it 'includes original exception message for TypeError' do
+      # Mock to cause TypeError within ResultsetLoader's processing
+      allow(JSON).to receive(:load_file).with(anything).and_return(malformed_resultset)
+
+      expect do
+        described_class.new(root: root, resultset: 'coverage')
+      end.to raise_error(SimpleCovMcp::CoverageDataError) do |error|
+        expect(error.message).to include('Invalid coverage data structure')
+        expect(error.message).to include('suite "RSpec"')
       end
     end
   end
@@ -186,7 +194,7 @@ RSpec.describe SimpleCovMcp::CoverageModel, 'error handling' do
       )
 
       expect do
-        SimpleCovMcp::CoverageModel.new(root: root, resultset: '/nonexistent/path')
+        described_class.new(root: root, resultset: '/nonexistent/path')
       end.to raise_error(SimpleCovMcp::ResultsetNotFoundError) do |error|
         expect(error.message).to include('Specified resultset not found')
       end
@@ -199,10 +207,63 @@ RSpec.describe SimpleCovMcp::CoverageModel, 'error handling' do
       )
 
       expect do
-        SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
+        described_class.new(root: root, resultset: 'coverage')
       end.to raise_error(SimpleCovMcp::ResultsetNotFoundError) do |error|
         expect(error.message).to include('Something went wrong during resultset lookup')
       end
     end
+
+    it 'converts RuntimeError without "resultset" in message to CoverageDataError' do
+      # Test RuntimeError that does NOT contain 'resultset' in its message
+      # This exercises the else branch in the RuntimeError rescue clause
+      allow(SimpleCovMcp::CovUtil).to receive(:find_resultset).and_raise(
+        RuntimeError.new('Some completely unrelated runtime error')
+      )
+
+      expect do
+        described_class.new(root: root, resultset: 'coverage')
+      end.to raise_error(SimpleCovMcp::CoverageDataError) do |error|
+        expect(error.message).to include('Failed to load coverage data')
+        expect(error.message).to include('Some completely unrelated runtime error')
+      end
+    end
+  end
+
+  describe 'all_files error handling' do
+    it 'skips files that raise FileError during coverage lookup' do
+      # This exercises the `next` statement in the all_files loop when FileError is raised
+      model = described_class.new(root: root, resultset: 'coverage')
+
+      # Mock lookup_lines to raise FileError for one specific file
+      allow(SimpleCovMcp::CovUtil).to receive(:lookup_lines).and_call_original
+      allow(SimpleCovMcp::CovUtil).to receive(:lookup_lines)
+        .with(anything, include('/lib/foo.rb'))
+        .and_raise(SimpleCovMcp::FileError.new('Corrupted coverage entry'))
+
+      # Should not raise, just skip the problematic file
+      result = model.all_files(check_stale: false)
+
+      # The result should contain bar.rb but not foo.rb
+      file_names = result.map { |r| File.basename(r['file']) }
+      expect(file_names).to include('bar.rb')
+      expect(file_names).not_to include('foo.rb')
+    end
+  end
+
+  describe 'resolve method error handling' do
+    it 'converts RuntimeError from lookup_lines to FileError' do
+      # This exercises the RuntimeError rescue clause in the resolve method
+      model = described_class.new(root: root, resultset: 'coverage')
+
+      # Mock lookup_lines to raise RuntimeError for a specific file
+      allow(SimpleCovMcp::CovUtil).to receive(:lookup_lines)
+        .and_raise(RuntimeError.new('Unexpected runtime error during lookup'))
+
+      expect do
+        model.summary_for('nonexistent_file.rb')
+      end.to raise_error(SimpleCovMcp::FileError) do |error|
+        expect(error.message).to include('No coverage data found for file')
+      end
+    end
   end
 end

data/spec/model_staleness_spec.rb

@@ -1,18 +1,19 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'tempfile'
 
 RSpec.describe SimpleCovMcp::CoverageModel do
   let(:root) { (FIXTURES_DIR / 'project1').to_s }
 
-  def with_stubbed_coverage_timestamp(ts) = begin
-    mock_resultset_with_timestamp(root, ts)
+  def with_stubbed_coverage_timestamp(timestamp)
+    mock_resultset_with_timestamp(root, timestamp)
     yield
   end
 
   it "raises stale error when staleness mode is 'error' and file is newer" do
     with_stubbed_coverage_timestamp(VERY_OLD_TIMESTAMP) do
-      model = described_class.new(root: root, staleness: 'error')
+      model = described_class.new(root: root, staleness: :error)
       expect do
         model.summary_for('lib/foo.rb')
       end.to raise_error(SimpleCovMcp::CoverageDataStaleError, /stale/i)
@@ -21,28 +22,27 @@ RSpec.describe SimpleCovMcp::CoverageModel do
 
   it "does not check staleness when mode is 'off'" do
     with_stubbed_coverage_timestamp(VERY_OLD_TIMESTAMP) do
-      model = described_class.new(root: root, staleness: 'off')
+      model = described_class.new(root: root, staleness: :off)
       expect { model.summary_for('lib/foo.rb') }.not_to raise_error
     end
   end
+
   it 'all_files raises project-level stale when any source file is newer than coverage' do
     with_stubbed_coverage_timestamp(VERY_OLD_TIMESTAMP) do
-      model = described_class.new(root: root, staleness: 'error')
+      model = described_class.new(root: root, staleness: :error)
       expect { model.all_files }.to raise_error(SimpleCovMcp::CoverageDataProjectStaleError)
     end
   end
 
   it 'all_files detects new files via tracked_globs' do
     with_stubbed_coverage_timestamp(Time.now.to_i) do
-      tmp = File.join(root, 'lib', 'brand_new_file.rb')
-      begin
-        File.write(tmp, "# new file\n")
-        model = described_class.new(root: root, staleness: 'error')
+      Tempfile.create(['brand_new_file', '.rb'], File.join(root, 'lib')) do |f|
+        f.write("# new file\n")
+        f.flush
+        model = described_class.new(root: root, staleness: :error)
         expect do
           model.all_files(tracked_globs: ['lib/**/*.rb'])
         end.to raise_error(SimpleCovMcp::CoverageDataProjectStaleError)
-      ensure
-        File.delete(tmp) if File.exist?(tmp)
       end
     end
   end
@@ -52,7 +52,7 @@ RSpec.describe SimpleCovMcp::CoverageModel do
       created_at = Time.new(2024, 7, 3, 16, 26, 40, '-07:00')
       mock_resultset_with_created_at(root, created_at.strftime('%Y-%m-%d %H:%M:%S %z'))
 
-      model = described_class.new(root: root, staleness: 'off')
+      model = described_class.new(root: root, staleness: :off)
 
       expect(model.instance_variable_get(:@cov_timestamp)).to eq(created_at.to_i)
     end
@@ -66,7 +66,7 @@ RSpec.describe SimpleCovMcp::CoverageModel do
       }
       mock_resultset_with_created_at(root, created_at_time.iso8601, coverage: mismatched_coverage)
 
-      model = described_class.new(root: root, staleness: 'error')
+      model = described_class.new(root: root, staleness: :error)
 
       expect(model.instance_variable_get(:@cov_timestamp)).to eq(created_at_time.to_i)
       expect do