simplecov-mcp 1.0.1 → 2.0.1

data/spec/presenters/project_coverage_presenter_spec.rb

@@ -3,6 +3,15 @@
 require 'spec_helper'
 
 RSpec.describe SimpleCovMcp::Presenters::ProjectCoveragePresenter do
+  subject(:presenter) do
+    described_class.new(
+      model: model,
+      sort_order: sort_order,
+      check_stale: check_stale,
+      tracked_globs: tracked_globs
+    )
+  end
+
   let(:model) { instance_double(SimpleCovMcp::CoverageModel) }
   let(:sort_order) { :ascending }
   let(:check_stale) { true }
@@ -26,14 +35,6 @@ RSpec.describe SimpleCovMcp::Presenters::ProjectCoveragePresenter do
     ]
   end
 
-  subject(:presenter) do
-    described_class.new(
-      model: model,
-      sort_order: sort_order,
-      check_stale: check_stale,
-      tracked_globs: tracked_globs
-    )
-  end
 
   before do
     allow(model).to receive(:all_files).with(sort_order: sort_order, check_stale: check_stale,

data/spec/presenters/project_totals_presenter_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::Presenters::ProjectTotalsPresenter do
+  subject(:presenter) do
+    described_class.new(
+      model: model,
+      check_stale: true,
+      tracked_globs: ['lib/**/*.rb']
+    )
+  end
+
+  let(:model) { instance_double(SimpleCovMcp::CoverageModel) }
+  let(:raw_totals) do
+    {
+      'lines' => { 'total' => 100, 'covered' => 80, 'uncovered' => 20 },
+      'percentage' => 80.0,
+      'files' => { 'total' => 10, 'ok' => 9, 'stale' => 1 }
+    }
+  end
+
+  before do
+    allow(model).to receive(:project_totals)
+      .with(tracked_globs: ['lib/**/*.rb'], check_stale: true)
+      .and_return(raw_totals)
+    allow(model).to receive(:relativize) { |payload| payload }
+  end
+
+  describe '#initialize' do
+    it 'stores the model, check_stale, and tracked_globs options' do
+      expect(presenter.model).to eq(model)
+      expect(presenter.check_stale).to be(true)
+      expect(presenter.tracked_globs).to eq(['lib/**/*.rb'])
+    end
+  end
+
+  describe '#absolute_payload' do
+    it 'returns project totals from the model' do
+      result = presenter.absolute_payload
+
+      expect(result).to include('lines', 'percentage', 'files')
+      expect(result['lines']).to include('total' => 100, 'covered' => 80, 'uncovered' => 20)
+      expect(result['percentage']).to eq(80.0)
+      expect(result['files']).to include('total' => 10, 'ok' => 9, 'stale' => 1)
+    end
+
+    it 'caches the result on subsequent calls' do
+      presenter.absolute_payload
+      presenter.absolute_payload
+
+      expect(model).to have_received(:project_totals).once
+    end
+
+    it 'passes tracked_globs to the model' do
+      presenter.absolute_payload
+
+      expect(model).to have_received(:project_totals)
+        .with(tracked_globs: ['lib/**/*.rb'], check_stale: true)
+    end
+  end
+
+  describe '#relativized_payload' do
+    it 'returns the relativized payload from the model' do
+      result = presenter.relativized_payload
+
+      expect(result).to eq(raw_totals)
+    end
+
+    it 'calls relativize on the model' do
+      presenter.relativized_payload
+
+      expect(model).to have_received(:relativize).with(raw_totals)
+    end
+
+    it 'caches the result on subsequent calls' do
+      presenter.relativized_payload
+      presenter.relativized_payload
+
+      expect(model).to have_received(:relativize).once
+    end
+  end
+
+  context 'with check_stale: false' do
+    subject(:presenter) do
+      described_class.new(
+        model: model,
+        check_stale: false,
+        tracked_globs: nil
+      )
+    end
+
+    before do
+      allow(model).to receive(:project_totals)
+        .with(tracked_globs: nil, check_stale: false)
+        .and_return(raw_totals)
+    end
+
+    it 'passes check_stale: false to the model' do
+      presenter.absolute_payload
+
+      expect(model).to have_received(:project_totals)
+        .with(tracked_globs: nil, check_stale: false)
+    end
+  end
+
+  context 'with empty tracked_globs' do
+    subject(:presenter) do
+      described_class.new(
+        model: model,
+        check_stale: true,
+        tracked_globs: []
+      )
+    end
+
+    before do
+      allow(model).to receive(:project_totals)
+        .with(tracked_globs: [], check_stale: true)
+        .and_return(raw_totals)
+    end
+
+    it 'passes empty tracked_globs to the model' do
+      presenter.absolute_payload
+
+      expect(model).to have_received(:project_totals)
+        .with(tracked_globs: [], check_stale: true)
+    end
+  end
+
+  context 'with relativization that transforms data' do
+    before do
+      allow(model).to receive(:relativize) do |payload|
+        # Simulate relativization that might transform file paths in nested data
+        payload.merge('transformed' => true)
+      end
+    end
+
+    it 'applies the transformation from relativize' do
+      result = presenter.relativized_payload
+
+      expect(result['transformed']).to be(true)
+    end
+  end
+end

data/spec/resolvers/coverage_line_resolver_spec.rb

@@ -4,54 +4,279 @@ require 'spec_helper'
 
 RSpec.describe SimpleCovMcp::Resolvers::CoverageLineResolver do
   describe '#lookup_lines' do
-    it 'synthesizes line hits when only branch coverage exists' do
-      abs_path = '/tmp/branch_only.rb'
-      branch_cov = {
-        abs_path => {
-          'lines' => nil,
-          'branches' => {
-            '[:if, 0, 5, 2, 8, 5]' => {
-              '[:then, 1, 6, 4, 6, 15]' => 3,
-              '[:else, 2, 7, 4, 7, 15]' => 0
-            },
-            '[:case, 3, 12, 2, 17, 5]' => {
-              '[:when, 4, 13, 4, 13, 14]' => 0,
-              '[:when, 5, 14, 4, 14, 14]' => 2,
-              '[:else, 6, 16, 4, 16, 12]' => 2
+    context 'with direct path matching' do
+      it 'returns lines array for exact path match' do
+        abs_path = '/project/lib/foo.rb'
+        cov_data = {
+          abs_path => { 'lines' => [1, 0, nil, 2] }
+        }
+
+        resolver = described_class.new(cov_data)
+        lines = resolver.lookup_lines(abs_path)
+
+        expect(lines).to eq([1, 0, nil, 2])
+      end
+
+      it 'returns lines array when entry has lines directly' do
+        path = '/tmp/test.rb'
+        cov_data = {
+          path => { 'lines' => [1, 1, 1] }
+        }
+
+        resolver = described_class.new(cov_data)
+        expect(resolver.lookup_lines(path)).to eq([1, 1, 1])
+      end
+    end
+
+    context 'with CWD stripping fallback' do
+      it 'finds relative path when absolute path includes CWD' do
+        cwd = Dir.pwd
+        relative_path = 'lib/bar.rb'
+        abs_path = File.join(cwd, relative_path)
+        cov_data = {
+          relative_path => { 'lines' => [1, 0, 1] }
+        }
+
+        resolver = described_class.new(cov_data)
+        lines = resolver.lookup_lines(abs_path)
+
+        expect(lines).to eq([1, 0, 1])
+      end
+
+      it 'does not match when absolute path does not start with CWD' do
+        cov_data = {
+          'lib/baz.rb' => { 'lines' => [1, 1] }
+        }
+
+        resolver = described_class.new(cov_data)
+
+        expect do
+          resolver.lookup_lines('/other/directory/lib/baz.rb')
+        end.to raise_error(SimpleCovMcp::FileError, /No coverage entry found/)
+      end
+    end
+
+    context 'when handling errors' do
+      it 'raises FileError when file is not found in coverage data' do
+        cov_data = {
+          '/project/lib/foo.rb' => { 'lines' => [1, 0] }
+        }
+
+        resolver = described_class.new(cov_data)
+
+        expect do
+          resolver.lookup_lines('/project/lib/missing.rb')
+        end.to raise_error(SimpleCovMcp::FileError, /No coverage entry found/)
+      end
+
+      it 'raises FileError when coverage data is empty' do
+        resolver = described_class.new({})
+
+        expect do
+          resolver.lookup_lines('/any/path.rb')
+        end.to raise_error(SimpleCovMcp::FileError, /No coverage entry found/)
+      end
+
+      it 'raises FileError when entry exists but has no lines or branches' do
+        cov_data = {
+          '/project/lib/foo.rb' => { 'other_key' => 'value' }
+        }
+
+        resolver = described_class.new(cov_data)
+
+        expect do
+          resolver.lookup_lines('/project/lib/foo.rb')
+        end.to raise_error(SimpleCovMcp::FileError, /No coverage entry found/)
+      end
+    end
+
+    context 'with branch-only coverage synthesis' do
+      it 'synthesizes line hits when only branch coverage exists' do
+        abs_path = '/tmp/branch_only.rb'
+        branch_cov = {
+          abs_path => {
+            'lines' => nil,
+            'branches' => {
+              '[:if, 0, 5, 2, 8, 5]' => {
+                '[:then, 1, 6, 4, 6, 15]' => 3,
+                '[:else, 2, 7, 4, 7, 15]' => 0
+              },
+              '[:case, 3, 12, 2, 17, 5]' => {
+                '[:when, 4, 13, 4, 13, 14]' => 0,
+                '[:when, 5, 14, 4, 14, 14]' => 2,
+                '[:else, 6, 16, 4, 16, 12]' => 2
+              }
             }
           }
         }
-      }
 
-      resolver = described_class.new(branch_cov)
-      lines = resolver.lookup_lines(abs_path)
+        resolver = described_class.new(branch_cov)
+        lines = resolver.lookup_lines(abs_path)
+
+        expect(lines[5]).to eq(3)  # line 6
+        expect(lines[6]).to eq(0)  # line 7
+        expect(lines[12]).to eq(0) # line 13
+        expect(lines[13]).to eq(2) # line 14
+        expect(lines[15]).to eq(2) # line 16
+        expect(lines.count { |v| !v.nil? }).to eq(5)
+      end
+
+      it 'aggregates hits for multiple branches on the same line' do
+        path = '/tmp/duplicated.rb'
+        branch_cov = {
+          path => {
+            'lines' => nil,
+            'branches' => {
+              '[:if, 0, 3, 2, 3, 12]' => {
+                '[:then, 1, 3, 2, 3, 12]' => 2,
+                '[:else, 2, 3, 2, 3, 12]' => 3
+              }
+            }
+          }
+        }
+
+        resolver = described_class.new(branch_cov)
+        lines = resolver.lookup_lines(path)
+
+        expect(lines[2]).to eq(5) # line 3 with summed hits
+      end
+
+      it 'handles array-style branch metadata' do
+        path = '/tmp/array_style.rb'
+        cov_data = {
+          path => {
+            'lines' => nil,
+            'branches' => {
+              [:if, 0, 5, 2, 8, 5] => {
+                [:then, 1, 6, 4, 6, 15] => 2
+              }
+            }
+          }
+        }
+
+        resolver = described_class.new(cov_data)
+        lines = resolver.lookup_lines(path)
+
+        expect(lines[5]).to eq(2) # line 6
+      end
+
+      it 'returns nil for entries with empty branches' do
+        path = '/tmp/empty_branches.rb'
+        cov_data = {
+          path => {
+            'lines' => nil,
+            'branches' => {}
+          }
+        }
+
+        resolver = described_class.new(cov_data)
+
+        expect do
+          resolver.lookup_lines(path)
+        end.to raise_error(SimpleCovMcp::FileError)
+      end
+
+      it 'skips malformed branch entries' do
+        path = '/tmp/malformed.rb'
+        cov_data = {
+          path => {
+            'lines' => nil,
+            'branches' => {
+              '[:if, 0, 5, 2, 8, 5]' => {
+                '[:then, 1, 6, 4, 6, 15]' => 2
+              },
+              'malformed_key' => 'not_a_hash',
+              '[:if, 1, 10]' => { # missing elements in tuple
+                '[:then]' => 1 # also malformed
+              }
+            }
+          }
+        }
+
+        resolver = described_class.new(cov_data)
+        lines = resolver.lookup_lines(path)
+
+        # Should still get line 6 from the valid branch
+        expect(lines[5]).to eq(2)
+      end
+    end
+
+    context 'with extract_line_number edge cases' do
+      let(:resolver) { described_class.new({}) }
+
+      it 'extracts line number from array metadata' do
+        result = resolver.send(:extract_line_number, [:if, 0, 10, 2, 15, 5])
+        expect(result).to eq(10)
+      end
+
+      it 'extracts line number from stringified array metadata' do
+        result = resolver.send(:extract_line_number, '[:if, 0, 15, 2, 20, 5]')
+        expect(result).to eq(15)
+      end
+
+      it 'returns nil for short array' do
+        result = resolver.send(:extract_line_number, [:if, 0])
+        expect(result).to be_nil
+      end
+
+      it 'returns nil for short string' do
+        result = resolver.send(:extract_line_number, '[:if, 0]')
+        expect(result).to be_nil
+      end
+
+      it 'returns nil for non-numeric line element in array' do
+        result = resolver.send(:extract_line_number, [:if, 0, 'not_a_number', 2])
+        expect(result).to be_nil
+      end
+
+      it 'returns nil for non-numeric line element in string' do
+        result = resolver.send(:extract_line_number, '[:if, 0, abc, 2]')
+        expect(result).to be_nil
+      end
+
+      it 'handles empty string' do
+        result = resolver.send(:extract_line_number, '')
+        expect(result).to be_nil
+      end
+
+      it 'handles nil input' do
+        result = resolver.send(:extract_line_number, nil)
+        expect(result).to be_nil
+      end
+
+      # The rescue block catches ArgumentError/TypeError from malformed metadata
+      # that can't be converted to line numbers.
+      [ArgumentError, TypeError].each do |error_class|
+        it "returns nil when string operations raise #{error_class}" do
+          weird_object = Object.new
+          allow(weird_object).to receive(:to_s).and_raise(error_class, 'test error')
 
-      expect(lines[5]).to eq(3)  # line 6
-      expect(lines[6]).to eq(0)  # line 7
-      expect(lines[12]).to eq(0) # line 13
-      expect(lines[13]).to eq(2) # line 14
-      expect(lines[15]).to eq(2) # line 16
-      expect(lines.count { |v| !v.nil? }).to eq(5)
+          result = resolver.send(:extract_line_number, weird_object)
+          expect(result).to be_nil
+        end
+      end
     end
 
-    it 'aggregates hits for multiple branches on the same line' do
-      path = '/tmp/duplicated.rb'
-      branch_cov = {
-        path => {
-          'lines' => nil,
-          'branches' => {
-            '[:if, 0, 3, 2, 3, 12]' => {
-              '[:then, 1, 3, 2, 3, 12]' => 2,
-              '[:else, 2, 3, 2, 3, 12]' => 3
+    context 'with preference for lines over branches' do
+      it 'prefers lines array when both lines and branches exist' do
+        path = '/tmp/both.rb'
+        cov_data = {
+          path => {
+            'lines' => [1, 2, 3],
+            'branches' => {
+              '[:if, 0, 100, 2, 105, 5]' => {
+                '[:then, 1, 101, 4, 101, 15]' => 99
+              }
             }
           }
         }
-      }
 
-      resolver = described_class.new(branch_cov)
-      lines = resolver.lookup_lines(path)
+        resolver = described_class.new(cov_data)
+        lines = resolver.lookup_lines(path)
 
-      expect(lines[2]).to eq(5) # line 3 with summed hits
+        # Should return the lines array, not synthesized branch data
+        expect(lines).to eq([1, 2, 3])
+      end
     end
   end
 end

data/spec/resolvers/resultset_path_resolver_spec.rb

@@ -2,19 +2,17 @@
 
 require 'spec_helper'
 require 'tmpdir'
+require 'fileutils'
 
 RSpec.describe SimpleCovMcp::Resolvers::ResultsetPathResolver do
   describe '#find_resultset' do
-    around do |example|
-      Dir.mktmpdir do |dir|
-        @tmp_root = dir
-        example.run
-      end
-    end
-
-    let(:root) { @tmp_root }
+    let(:root) { Dir.mktmpdir }
     let(:resolver) { described_class.new(root: root) }
 
+    after do
+      FileUtils.remove_entry(root) if root && Dir.exist?(root)
+    end
+
     it 'raises when a specified resultset file cannot be found' do
       expect do
         resolver.find_resultset(resultset: 'missing.json')
@@ -51,5 +49,12 @@ RSpec.describe SimpleCovMcp::Resolvers::ResultsetPathResolver do
 
       expect(resolved).to eq(File.join(project_root, 'coverage', '.resultset.json'))
     end
+
+    # In non-strict mode, resolve_candidate returns nil instead of raising
+    # when the path doesn't exist, allowing fallback resolution to continue.
+    it 'returns nil for non-existent path in non-strict mode' do
+      result = resolver.send(:resolve_candidate, '/nonexistent/path.json', strict: false)
+      expect(result).to be_nil
+    end
   end
 end

data/spec/shared_examples/file_based_mcp_tools.rb

@@ -9,6 +9,8 @@ require 'spec_helper'
 # - Have predictable output filename
 
 RSpec.shared_examples 'a file-based MCP tool' do |config|
+  subject { tool_class.call(path: 'lib/foo.rb', server_context: server_context) }
+
   let(:server_context) { instance_double('ServerContext').as_null_object }
   let(:tool_class) { config[:tool_class] }
   let(:model_method) { config[:model_method] }
@@ -31,7 +33,6 @@ RSpec.shared_examples 'a file-based MCP tool' do |config|
     allow(model).to receive(:staleness_for).with('lib/foo.rb').and_return(false)
   end
 
-  subject { tool_class.call(path: 'lib/foo.rb', server_context: server_context) }
 
   it_behaves_like 'an MCP tool that returns text JSON'
 
@@ -44,7 +45,7 @@ RSpec.shared_examples 'a file-based MCP tool' do |config|
     end
 
     expect(data).to have_key('stale')
-    expect(data['stale']).to eq(false)
+    expect(data['stale']).to be(false)
 
     # Run tool-specific validations if provided
     if additional_validations
@@ -56,7 +57,7 @@ RSpec.shared_examples 'a file-based MCP tool' do |config|
   tool_specific_examples = config[:tool_specific_examples] || {}
   tool_specific_examples.each do |example_name, example_block|
     it example_name do
-      instance_exec(config, &example_block)
+      expect { instance_exec(config, &example_block) }.not_to raise_error
     end
   end
 end
@@ -71,17 +72,19 @@ FILE_BASED_TOOL_CONFIGS = {
     description: 'coverage summary data',
     mock_data: {
       'file' => '/abs/path/lib/foo.rb',
-      'summary' => { 'covered' => 10, 'total' => 12, 'pct' => 83.33 }
+      'summary' => { 'covered' => 10, 'total' => 12, 'percentage' => 83.33 }
     },
-    additional_validations: ->(data, item) {
-      expect(data['summary']).to include('covered', 'total', 'pct')
+    additional_validations: ->(data, _item) {
+      expect(data['summary']).to include('covered', 'total', 'percentage')
     },
     tool_specific_examples: {
       'includes percentage in summary data' => ->(config) {
         model = instance_double(SimpleCovMcp::CoverageModel)
         allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
-        allow(model).to receive(:summary_for).and_return(config[:mock_data])
-        allow(model).to receive(:staleness_for).and_return(false)
+        allow(model).to receive_messages(
+          summary_for: config[:mock_data],
+          staleness_for: false
+        )
         relativizer = SimpleCovMcp::PathRelativizer.new(
           root: '/abs/path',
           scalar_keys: %w[file file_path],
@@ -92,9 +95,9 @@ FILE_BASED_TOOL_CONFIGS = {
 
         response = config[:tool_class].call(path: 'lib/foo.rb',
           server_context: instance_double('ServerContext').as_null_object)
-        data, _ = expect_mcp_text_json(response)
+        data, = expect_mcp_text_json(response)
 
-        expect(data['summary']['pct']).to be_a(Float)
+        expect(data['summary']['percentage']).to be_a(Float)
       }
     }
   },
@@ -123,17 +126,19 @@ FILE_BASED_TOOL_CONFIGS = {
     mock_data: {
       'file' => '/abs/path/lib/foo.rb',
       'uncovered' => [5, 9, 12],
-      'summary' => { 'covered' => 10, 'total' => 12, 'pct' => 83.33 }
+      'summary' => { 'covered' => 10, 'total' => 12, 'percentage' => 83.33 }
     },
-    additional_validations: ->(data, item) {
+    additional_validations: ->(data, _item) {
       expect(data['uncovered']).to eq([5, 9, 12])
     },
     tool_specific_examples: {
       'includes both uncovered lines and summary' => ->(config) {
         model = instance_double(SimpleCovMcp::CoverageModel)
         allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
-        allow(model).to receive(:uncovered_for).and_return(config[:mock_data])
-        allow(model).to receive(:staleness_for).and_return(false)
+        allow(model).to receive_messages(
+          uncovered_for: config[:mock_data],
+          staleness_for: false
+        )
         relativizer = SimpleCovMcp::PathRelativizer.new(
           root: '/abs/path',
           scalar_keys: %w[file file_path],
@@ -144,10 +149,10 @@ FILE_BASED_TOOL_CONFIGS = {
 
         response = config[:tool_class].call(path: 'lib/foo.rb',
           server_context: instance_double('ServerContext').as_null_object)
-        data, _ = expect_mcp_text_json(response)
+        data, = expect_mcp_text_json(response)
 
         expect(data['uncovered']).to be_an(Array)
-        expect(data['summary']).to include('covered', 'total', 'pct')
+        expect(data['summary']).to include('covered', 'total', 'percentage')
       }
     }
   },
@@ -164,9 +169,9 @@ FILE_BASED_TOOL_CONFIGS = {
         { '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 }
     },
-    additional_validations: ->(data, item) {
+    additional_validations: ->(data, _item) {
       expect(data['lines']).to be_an(Array)
       expect(data['lines'].first).to include('line', 'hits', 'covered')
     }