simplecov-mcp 1.0.1 → 2.0.1

data/spec/option_normalizers_spec.rb

@@ -5,25 +5,17 @@ require 'spec_helper'
 RSpec.describe SimpleCovMcp::OptionNormalizers do
   describe '.normalize_sort_order' do
     context 'with strict mode (default)' do
-      it 'normalizes "a" to :ascending' do
-        expect(described_class.normalize_sort_order('a')).to eq(:ascending)
-      end
-
-      it 'normalizes "ascending" to :ascending' do
-        expect(described_class.normalize_sort_order('ascending')).to eq(:ascending)
-      end
-
-      it 'normalizes "d" to :descending' do
-        expect(described_class.normalize_sort_order('d')).to eq(:descending)
-      end
-
-      it 'normalizes "descending" to :descending' do
-        expect(described_class.normalize_sort_order('descending')).to eq(:descending)
-      end
-
-      it 'is case-insensitive' do
-        expect(described_class.normalize_sort_order('ASCENDING')).to eq(:ascending)
-        expect(described_class.normalize_sort_order('Descending')).to eq(:descending)
+      [
+        ['a', :ascending],
+        ['ascending', :ascending],
+        ['d', :descending],
+        ['descending', :descending],
+        ['ASCENDING', :ascending],
+        ['Descending', :descending]
+      ].each do |input, expected|
+        it "normalizes '#{input}' to #{expected}" do
+          expect(described_class.normalize_sort_order(input)).to eq(expected)
+        end
       end
 
       it 'raises OptionParser::InvalidArgument for invalid values' do
@@ -45,33 +37,24 @@ RSpec.describe SimpleCovMcp::OptionNormalizers do
 
   describe '.normalize_source_mode' do
     context 'with strict mode (default)' do
-      it 'normalizes nil to :full' do
-        expect(described_class.normalize_source_mode(nil)).to eq(:full)
-      end
-
-      it 'normalizes empty string to :full' do
-        expect(described_class.normalize_source_mode('')).to eq(:full)
-      end
-
-      it 'normalizes "f" to :full' do
-        expect(described_class.normalize_source_mode('f')).to eq(:full)
-      end
-
-      it 'normalizes "full" to :full' do
-        expect(described_class.normalize_source_mode('full')).to eq(:full)
-      end
-
-      it 'normalizes "u" to :uncovered' do
-        expect(described_class.normalize_source_mode('u')).to eq(:uncovered)
-      end
-
-      it 'normalizes "uncovered" to :uncovered' do
-        expect(described_class.normalize_source_mode('uncovered')).to eq(:uncovered)
-      end
-
-      it 'is case-insensitive' do
-        expect(described_class.normalize_source_mode('FULL')).to eq(:full)
-        expect(described_class.normalize_source_mode('Uncovered')).to eq(:uncovered)
+      [nil, ''].each do |input|
+        it "raises OptionParser::InvalidArgument for #{input.inspect}" do
+          expect { described_class.normalize_source_mode(input) }
+            .to raise_error(OptionParser::InvalidArgument, /invalid argument/)
+        end
+      end
+
+      [
+        ['f', :full],
+        ['full', :full],
+        ['u', :uncovered],
+        ['uncovered', :uncovered],
+        ['FULL', :full],
+        ['Uncovered', :uncovered]
+      ].each do |input, expected|
+        it "normalizes '#{input}' to #{expected}" do
+          expect(described_class.normalize_source_mode(input)).to eq(expected)
+        end
       end
 
       it 'raises OptionParser::InvalidArgument for invalid values' do
@@ -91,84 +74,70 @@ RSpec.describe SimpleCovMcp::OptionNormalizers do
     end
   end
 
-  describe '.normalize_stale_mode' do
+  describe '.normalize_staleness' do
     context 'with strict mode (default)' do
-      it 'normalizes "o" to :off' do
-        expect(described_class.normalize_stale_mode('o')).to eq(:off)
-      end
-
-      it 'normalizes "off" to :off' do
-        expect(described_class.normalize_stale_mode('off')).to eq(:off)
-      end
-
-      it 'normalizes "e" to :error' do
-        expect(described_class.normalize_stale_mode('e')).to eq(:error)
-      end
-
-      it 'normalizes "error" to :error' do
-        expect(described_class.normalize_stale_mode('error')).to eq(:error)
-      end
-
-      it 'is case-insensitive' do
-        expect(described_class.normalize_stale_mode('OFF')).to eq(:off)
-        expect(described_class.normalize_stale_mode('Error')).to eq(:error)
+      [
+        ['o', :off],
+        ['off', :off],
+        ['e', :error],
+        ['error', :error],
+        ['OFF', :off],
+        ['Error', :error]
+      ].each do |input, expected|
+        it "normalizes '#{input}' to #{expected}" do
+          expect(described_class.normalize_staleness(input)).to eq(expected)
+        end
       end
 
       it 'raises OptionParser::InvalidArgument for invalid values' do
-        expect { described_class.normalize_stale_mode('invalid') }
+        expect { described_class.normalize_staleness('invalid') }
           .to raise_error(OptionParser::InvalidArgument, /invalid argument: invalid/)
       end
     end
 
     context 'with strict: false' do
       it 'returns nil for invalid values' do
-        expect(described_class.normalize_stale_mode('invalid', strict: false)).to be_nil
+        expect(described_class.normalize_staleness('invalid', strict: false)).to be_nil
       end
 
       it 'still normalizes valid values' do
-        expect(described_class.normalize_stale_mode('e', strict: false)).to eq(:error)
+        expect(described_class.normalize_staleness('e', strict: false)).to eq(:error)
       end
     end
   end
 
   describe '.normalize_error_mode' do
     context 'with strict mode (default)' do
-      it 'normalizes "off" to :off' do
-        expect(described_class.normalize_error_mode('off')).to eq(:off)
-      end
-
-      it 'normalizes "on" to :on' do
-        expect(described_class.normalize_error_mode('on')).to eq(:on)
-      end
-
-      it 'normalizes "trace" to :trace' do
-        expect(described_class.normalize_error_mode('trace')).to eq(:trace)
-      end
-
-      it 'normalizes "t" to :trace' do
-        expect(described_class.normalize_error_mode('t')).to eq(:trace)
-      end
-
-      it 'is case-insensitive' do
-        expect(described_class.normalize_error_mode('OFF')).to eq(:off)
-        expect(described_class.normalize_error_mode('On')).to eq(:on)
-        expect(described_class.normalize_error_mode('TRACE')).to eq(:trace)
-      end
-
-      it 'raises OptionParser::InvalidArgument for invalid values' do
-        expect { described_class.normalize_error_mode('invalid') }
-          .to raise_error(OptionParser::InvalidArgument, /invalid argument: invalid/)
+      [
+        ['off', :off],
+        ['o', :off],
+        ['log', :log],
+        ['l', :log],
+        ['debug', :debug],
+        ['d', :debug],
+        ['OFF', :off],
+        ['Log', :log],
+        ['DEBUG', :debug]
+      ].each do |input, expected|
+        it "normalizes '#{input}' to #{expected}" do
+          expect(described_class.normalize_error_mode(input)).to eq(expected)
+        end
+      end
+
+      ['invalid', 'on', 'trace'].each do |input|
+        it "raises OptionParser::InvalidArgument for '#{input}'" do
+          expect { described_class.normalize_error_mode(input) }
+            .to raise_error(OptionParser::InvalidArgument, /invalid argument: #{input}/)
+        end
       end
     end
 
-    context 'with strict: false and default: :on' do
-      it 'returns default for invalid values' do
-        expect(described_class.normalize_error_mode('invalid', strict: false,
-          default: :on)).to eq(:on)
-      end
-
-      it 'returns default for nil' do
-        expect(described_class.normalize_error_mode(nil, strict: false, default: :on)).to eq(:on)
+    context 'with strict: false and default: :log' do
+      [['invalid', :log], [nil, :log]].each do |input, expected|
+        it "returns default #{expected} for #{input.inspect}" do
+          expect(described_class.normalize_error_mode(input, strict: false,
+            default: :log)).to eq(expected)
+        end
       end
 
       it 'still normalizes valid values' do
@@ -184,21 +153,51 @@ RSpec.describe SimpleCovMcp::OptionNormalizers do
     end
   end
 
-  describe 'constant maps' do
-    it 'has frozen SORT_ORDER_MAP' do
-      expect(described_class::SORT_ORDER_MAP).to be_frozen
-    end
+  describe '.normalize_format' do
+    context 'with strict mode (default)' do
+      [
+        ['t', :table],
+        ['table', :table],
+        ['j', :json],
+        ['json', :json],
+        ['pretty_json', :pretty_json],
+        ['pretty-json', :pretty_json],
+        ['y', :yaml],
+        ['yaml', :yaml],
+        ['a', :awesome_print],
+        ['awesome_print', :awesome_print],
+        ['ap', :awesome_print],
+        ['TABLE', :table],
+        ['Json', :json]
+      ].each do |input, expected|
+        it "normalizes '#{input}' to #{expected}" do
+          expect(described_class.normalize_format(input)).to eq(expected)
+        end
+      end
 
-    it 'has frozen SOURCE_MODE_MAP' do
-      expect(described_class::SOURCE_MODE_MAP).to be_frozen
+      it 'raises OptionParser::InvalidArgument for invalid values' do
+        expect { described_class.normalize_format('invalid') }
+          .to raise_error(OptionParser::InvalidArgument, /invalid argument: invalid/)
+      end
     end
 
-    it 'has frozen STALE_MODE_MAP' do
-      expect(described_class::STALE_MODE_MAP).to be_frozen
+    context 'with strict: false' do
+      it 'returns nil for invalid values' do
+        expect(described_class.normalize_format('invalid', strict: false)).to be_nil
+      end
+
+      it 'still normalizes valid values' do
+        expect(described_class.normalize_format('json', strict: false)).to eq(:json)
+      end
     end
+  end
 
-    it 'has frozen ERROR_MODE_MAP' do
-      expect(described_class::ERROR_MODE_MAP).to be_frozen
+  describe 'constant maps' do
+    [:SORT_ORDER_MAP, :SOURCE_MODE_MAP, :STALENESS_MAP, :ERROR_MODE_MAP,
+     :FORMAT_MAP].each do |const|
+      it "has frozen #{const}" do
+        expect(described_class.const_get(const)).to be_frozen
+      end
     end
   end
 end

data/spec/option_parsers/env_options_parser_spec.rb

@@ -30,8 +30,8 @@ RSpec.describe SimpleCovMcp::OptionParsers::EnvOptionsParser do
       end
 
       it 'parses simple options correctly' do
-        ENV['SIMPLECOV_MCP_OPTS'] = '--error-mode off --json'
-        expect(parser.parse_env_opts).to eq(['--error-mode', 'off', '--json'])
+        ENV['SIMPLECOV_MCP_OPTS'] = '--error-mode off --format json'
+        expect(parser.parse_env_opts).to eq(['--error-mode', 'off', '--format', 'json'])
       end
 
       it 'handles quoted strings with spaces' do
@@ -106,9 +106,9 @@ RSpec.describe SimpleCovMcp::OptionParsers::EnvOptionsParser do
 
     context 'when error-mode is found' do
       it 'extracts error-mode with space separator' do
-        argv = ['--error-mode', 'trace', '--other-option']
+        argv = ['--error-mode', 'debug', '--other-option']
         result = parser.pre_scan_error_mode(argv, error_mode_normalizer: error_mode_normalizer)
-        expect(result).to eq(:trace)
+        expect(result).to eq(:debug)
       end
 
       it 'extracts error-mode with equals separator' do
@@ -125,9 +125,9 @@ RSpec.describe SimpleCovMcp::OptionParsers::EnvOptionsParser do
       end
 
       it 'returns first error-mode when multiple are present' do
-        argv = ['--error-mode', 'on', '--error-mode', 'off']
+        argv = ['--error-mode', 'log', '--error-mode', 'off']
         result = parser.pre_scan_error_mode(argv, error_mode_normalizer: error_mode_normalizer)
-        expect(result).to eq(:on)
+        expect(result).to eq(:log)
       end
     end
 
@@ -145,25 +145,25 @@ RSpec.describe SimpleCovMcp::OptionParsers::EnvOptionsParser do
       end
     end
 
-    context 'error handling during pre-scan' do
+    context 'when handling errors during pre-scan' do
       it 'returns nil when normalizer raises an error' do
-        faulty_normalizer = ->(value) { raise StandardError, 'Intentional error' }
-        argv = ['--error-mode', 'on']
+        faulty_normalizer = ->(_) { raise StandardError, 'Intentional error' }
+        argv = ['--error-mode', 'log']
 
         result = parser.pre_scan_error_mode(argv, error_mode_normalizer: faulty_normalizer)
         expect(result).to be_nil
       end
 
       it 'returns nil when normalizer raises ArgumentError' do
-        faulty_normalizer = ->(value) { raise ArgumentError, 'Bad argument' }
-        argv = ['--error-mode', 'on']
+        faulty_normalizer = ->(_) { raise ArgumentError, 'Bad argument' }
+        argv = ['--error-mode', 'log']
 
         result = parser.pre_scan_error_mode(argv, error_mode_normalizer: faulty_normalizer)
         expect(result).to be_nil
       end
 
       it 'returns nil when normalizer raises RuntimeError' do
-        faulty_normalizer = ->(value) { raise RuntimeError, 'Runtime problem' }
+        faulty_normalizer = ->(_) { raise 'Runtime problem' }
         argv = ['--error-mode=off']
 
         result = parser.pre_scan_error_mode(argv, error_mode_normalizer: faulty_normalizer)
@@ -172,14 +172,6 @@ RSpec.describe SimpleCovMcp::OptionParsers::EnvOptionsParser do
     end
   end
 
-  describe 'integration with ErrorHandlerFactory' do
-    it 'maps trace alias to an accepted error_mode' do
-      mode = parser.pre_scan_error_mode(['--error-mode', 'trace'])
-      expect { SimpleCovMcp::ErrorHandlerFactory.for_cli(error_mode: mode) }.not_to raise_error
-      expect(mode).to eq(:trace)
-    end
-  end
-
   describe '#normalize_error_mode (private)' do
     it 'normalizes "off" to :off' do
       expect(parser.send(:normalize_error_mode, 'off')).to eq(:off)
@@ -187,29 +179,25 @@ RSpec.describe SimpleCovMcp::OptionParsers::EnvOptionsParser do
       expect(parser.send(:normalize_error_mode, 'Off')).to eq(:off)
     end
 
-    it 'normalizes "on" to :on' do
-      expect(parser.send(:normalize_error_mode, 'on')).to eq(:on)
-      expect(parser.send(:normalize_error_mode, 'ON')).to eq(:on)
-    end
-
-    it 'normalizes "trace" to :trace' do
-      expect(parser.send(:normalize_error_mode, 'trace')).to eq(:trace)
-      expect(parser.send(:normalize_error_mode, 'TRACE')).to eq(:trace)
+    it 'normalizes "log" to :log' do
+      expect(parser.send(:normalize_error_mode, 'log')).to eq(:log)
+      expect(parser.send(:normalize_error_mode, 'LOG')).to eq(:log)
+      expect(parser.send(:normalize_error_mode, 'Log')).to eq(:log)
     end
 
-    it 'normalizes "t" to :trace' do
-      expect(parser.send(:normalize_error_mode, 't')).to eq(:trace)
-      expect(parser.send(:normalize_error_mode, 'T')).to eq(:trace)
+    it 'normalizes "debug" to :debug' do
+      expect(parser.send(:normalize_error_mode, 'debug')).to eq(:debug)
+      expect(parser.send(:normalize_error_mode, 'DEBUG')).to eq(:debug)
     end
 
-    it 'defaults unknown values to :on' do
-      expect(parser.send(:normalize_error_mode, 'unknown')).to eq(:on)
-      expect(parser.send(:normalize_error_mode, 'invalid')).to eq(:on)
-      expect(parser.send(:normalize_error_mode, '')).to eq(:on)
+    it 'defaults unknown values to :log' do
+      expect(parser.send(:normalize_error_mode, 'unknown')).to eq(:log)
+      expect(parser.send(:normalize_error_mode, 'invalid')).to eq(:log)
+      expect(parser.send(:normalize_error_mode, '')).to eq(:log)
     end
 
-    it 'handles nil by defaulting to :on' do
-      expect(parser.send(:normalize_error_mode, nil)).to eq(:on)
+    it 'handles nil by defaulting to :log' do
+      expect(parser.send(:normalize_error_mode, nil)).to eq(:log)
     end
   end
 

data/spec/option_parsers/error_helper_spec.rb

@@ -2,6 +2,29 @@
 
 require 'spec_helper'
 
+OPTION_TESTS = {
+  staleness: {
+    long: '--staleness',
+    short: '-S',
+    pattern: /Valid values for --staleness: o\[ff\]|e\[rror\]/
+  },
+  source: {
+    long: '--source',
+    short: '-s',
+    pattern: /Valid values for --source: f\[ull\]|u\[ncovered\]/
+  },
+  error_mode: {
+    long: '--error-mode',
+    short: nil,
+    pattern: /Valid values for --error-mode: o\[ff\]|l\[og\]|d\[ebug\]/
+  },
+  sort_order: {
+    long: '--sort-order',
+    short: '-o',
+    pattern: /Valid values for --sort-order: a\[scending\]|d\[escending\]/
+  }
+}.freeze
+
 RSpec.describe SimpleCovMcp::OptionParsers::ErrorHelper do
   subject(:helper) { described_class.new }
 
@@ -23,42 +46,16 @@ RSpec.describe SimpleCovMcp::OptionParsers::ErrorHelper do
   # Helper method to test error output matches expected pattern
   def expect_error_output(error:, argv:, pattern:)
     expect do
-      begin
-        helper.handle_option_parser_error(error, argv: argv)
-      rescue SystemExit
-        # Ignore exit call
-      end
+      helper.handle_option_parser_error(error, argv: argv)
+    rescue SystemExit
+      # Ignore exit call
     end.to output(pattern).to_stderr
   end
 
-  # Test data for enumerated options
-  OPTION_TESTS = {
-    stale: {
-      long: '--stale',
-      short: '-S',
-      pattern: /Valid values for --stale: o\[ff\]|e\[rror\]/
-    },
-    source: {
-      long: '--source',
-      short: '-s',
-      pattern: /Valid values for --source: f\[ull\]|u\[ncovered\]/
-    },
-    error_mode: {
-      long: '--error-mode',
-      short: nil,
-      pattern: /Valid values for --error-mode: off\|on\|t\[race\]/
-    },
-    sort_order: {
-      long: '--sort-order',
-      short: '-o',
-      pattern: /Valid values for --sort-order: a\[scending\]|d\[escending\]/
-    }
-  }.freeze
-
   describe '#handle_option_parser_error' do
     context 'with invalid enumerated option values' do
-      OPTION_TESTS.each do |name, config|
-        context "for #{config[:long]} option" do
+      OPTION_TESTS.each_value do |config|
+        context "when parsing #{config[:long]} option" do
           let(:error) { OptionParser::InvalidArgument.new('invalid argument: xyz') }
 
           it 'suggests valid values for space-separated form with invalid value' do
@@ -89,13 +86,13 @@ RSpec.describe SimpleCovMcp::OptionParsers::ErrorHelper do
         end
       end
 
-      context 'for --stale option edge cases' do
+      context 'when handling --staleness option edge cases' do
         it 'suggests valid values when value is missing' do
-          error = OptionParser::InvalidArgument.new('missing argument: --stale')
+          error = OptionParser::InvalidArgument.new('missing argument: --staleness')
           expect_error_output(
             error: error,
-            argv: ['--stale'],
-            pattern: /Valid values for --stale: o\[ff\]|e\[rror\]/
+            argv: ['--staleness'],
+            pattern: /Valid values for --staleness: o\[ff\]|e\[rror\]/
           )
         end
 
@@ -103,8 +100,8 @@ RSpec.describe SimpleCovMcp::OptionParsers::ErrorHelper do
           error = OptionParser::InvalidArgument.new('invalid argument: --other')
           expect_error_output(
             error: error,
-            argv: ['--stale', '--other-option'],
-            pattern: /Valid values for --stale: o\[ff\]|e\[rror\]/
+            argv: ['--staleness', '--other-option'],
+            pattern: /Valid values for --staleness: o\[ff\]|e\[rror\]/
           )
         end
       end
@@ -115,8 +112,8 @@ RSpec.describe SimpleCovMcp::OptionParsers::ErrorHelper do
         error = OptionParser::InvalidArgument.new('invalid argument: bad')
         expect_error_output(
           error: error,
-          argv: ['--resultset', 'coverage', '--stale', 'bad', '--json'],
-          pattern: /Valid values for --stale: o\[ff\]|e\[rror\]/
+          argv: ['--resultset', 'coverage', '--staleness', 'bad', '--format', 'json'],
+          pattern: /Valid values for --staleness: o\[ff\]|e\[rror\]/
         )
       end
 
@@ -124,7 +121,7 @@ RSpec.describe SimpleCovMcp::OptionParsers::ErrorHelper do
         error = OptionParser::InvalidArgument.new('invalid argument: invalid')
         expect_error_output(
           error: error,
-          argv: ['--json', '--sort-order=invalid', '--resultset', 'coverage'],
+          argv: ['--format', 'json', '--sort-order=invalid', '--resultset', 'coverage'],
           pattern: /Valid values for --sort-order: a\[scending\]|d\[escending\]/
         )
       end
@@ -152,42 +149,44 @@ RSpec.describe SimpleCovMcp::OptionParsers::ErrorHelper do
           helper.handle_option_parser_error(error, argv: ['--summary'])
         end
 
-        # Note: The subcommand detection logic isn't fully working as expected
+        # NOTE: The subcommand detection logic isn't fully working as expected
         # because extract_invalid_option doesn't properly parse the error message
         expect(stderr_output).to match(/Error:.*--summary/)
         expect(stderr_output).to match(/Run 'simplecov-mcp --help'/)
       end
     end
 
-    context 'exit behavior' do
+    context 'when exiting after invalid option' do
       it 'exits with status 1' do
         error = OptionParser::InvalidArgument.new('invalid argument: xyz')
 
-        expect do
-          helper.handle_option_parser_error(error, argv: ['--stale', 'xyz'])
-        end.to raise_error(SystemExit) do |e|
-          expect(e.status).to eq(1)
+        stderr_output = capture_stderr do
+          expect do
+            helper.handle_option_parser_error(error, argv: ['--staleness', 'xyz'])
+          end.to raise_error(SystemExit) do |e|
+            expect(e.status).to eq(1)
+          end
         end
+
+        expect(stderr_output).to include('invalid argument: xyz')
       end
     end
 
-    context 'usage hint customization' do
+    context 'when customizing usage hint' do
       it 'uses custom usage hint when provided' do
         error = OptionParser::InvalidArgument.new('invalid argument: xyz')
 
         expect do
-          begin
-            helper.handle_option_parser_error(error, argv: ['--stale', 'xyz'],
-              usage_hint: 'Custom hint message')
-          rescue SystemExit
-            # Ignore exit call
-          end
+          helper.handle_option_parser_error(error, argv: ['--staleness', 'xyz'],
+            usage_hint: 'Custom hint message')
+        rescue SystemExit
+          # Ignore exit call
         end.to output(/Custom hint message/).to_stderr
       end
     end
   end
 
-  describe 'edge cases' do
+  describe 'when handling edge cases' do
     it 'handles empty argv gracefully' do
       error = OptionParser::InvalidArgument.new('some error')
       expect_error_output(
@@ -201,7 +200,8 @@ RSpec.describe SimpleCovMcp::OptionParsers::ErrorHelper do
       error = OptionParser::InvalidArgument.new('some error')
 
       stderr_output = capture_stderr do
-        helper.handle_option_parser_error(error, argv: ['--json', '--resultset', 'coverage'])
+        helper.handle_option_parser_error(error,
+          argv: ['--format', 'json', '--resultset', 'coverage'])
       end
 
       expect(stderr_output).to match(/Error: invalid argument: some error/)
@@ -212,7 +212,7 @@ RSpec.describe SimpleCovMcp::OptionParsers::ErrorHelper do
       error = OptionParser::MissingArgument.new('missing argument: --resultset')
 
       stderr_output = capture_stderr do
-        helper.handle_option_parser_error(error, argv: ['--stale', 'off', '--resultset'])
+        helper.handle_option_parser_error(error, argv: ['--staleness', 'off', '--resultset'])
       end
 
       expect(stderr_output).to match(/Error:.*missing argument.*--resultset/)

data/spec/path_relativizer_spec.rb

@@ -79,5 +79,20 @@ RSpec.describe SimpleCovMcp::PathRelativizer do
     ensure
       FileUtils.rm_f(file_with_space)
     end
+
+    # On Windows, relative_path_from raises ArgumentError for paths on different
+    # drives (e.g., C: vs D:). The rescue block returns the original path.
+    it 'returns original path when relative_path_from raises ArgumentError' do
+      fake_pathname = instance_double(Pathname)
+      allow(fake_pathname).to receive(:relative_path_from)
+        .and_raise(ArgumentError, 'different prefix')
+      allow(Pathname).to receive(:new).and_call_original
+      allow(Pathname).to receive(:new).with(File.absolute_path('lib/foo.rb', root))
+        .and_return(fake_pathname)
+
+      result = relativizer.relativize_path(File.join(root, 'lib/foo.rb'))
+
+      expect(result).to eq(File.join(root, 'lib/foo.rb'))
+    end
   end
 end

data/spec/presenters/coverage_detailed_presenter_spec.rb

@@ -12,7 +12,7 @@ RSpec.describe SimpleCovMcp::Presenters::CoverageDetailedPresenter do
         { 'line' => 1, 'hits' => 1, 'covered' => true },
         { 'line' => 2, 'hits' => 0, 'covered' => false }
       ],
-      'summary' => { 'covered' => 1, 'total' => 2, 'pct' => 50.0 }
+      'summary' => { 'covered' => 1, 'total' => 2, 'percentage' => 50.0 }
     },
     stale: 'L',
     expected_keys: ['lines', 'summary']

data/spec/presenters/coverage_summary_presenter_spec.rb

@@ -8,7 +8,7 @@ RSpec.describe SimpleCovMcp::Presenters::CoverageSummaryPresenter do
     model_method: :summary_for,
     payload: {
       'file' => '/abs/path/lib/foo.rb',
-      'summary' => { 'covered' => 8, 'total' => 10, 'pct' => 80.0 }
+      'summary' => { 'covered' => 8, 'total' => 10, 'percentage' => 80.0 }
     },
     stale: false,
     expected_keys: ['summary']

data/spec/presenters/coverage_uncovered_presenter_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe SimpleCovMcp::Presenters::CoverageUncoveredPresenter do
     payload: {
       'file' => '/abs/path/lib/foo.rb',
       'uncovered' => [2, 4],
-      'summary' => { 'covered' => 2, 'total' => 4, 'pct' => 50.0 }
+      'summary' => { 'covered' => 2, 'total' => 4, 'percentage' => 50.0 }
     },
     stale: 'M',
     expected_keys: ['uncovered', 'summary']