simplecov-mcp 0.3.0 → 1.0.0

data/spec/option_parsers/error_helper_spec.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::OptionParsers::ErrorHelper do
+  subject(:helper) { described_class.new }
+
+  # Helper method to capture stderr output
+  def capture_stderr
+    captured = StringIO.new
+    original = $stderr
+    $stderr = captured
+    begin
+      yield
+    rescue SystemExit
+      # Ignore exit calls
+    ensure
+      $stderr = original
+    end
+    captured.string
+  end
+
+  # 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
+    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
+          let(:error) { OptionParser::InvalidArgument.new('invalid argument: xyz') }
+
+          it 'suggests valid values for space-separated form with invalid value' do
+            expect_error_output(
+              error: error,
+              argv: [config[:long], 'xyz'],
+              pattern: config[:pattern]
+            )
+          end
+
+          it 'suggests valid values for equal form with invalid value' do
+            expect_error_output(
+              error: error,
+              argv: ["#{config[:long]}=xyz"],
+              pattern: config[:pattern]
+            )
+          end
+
+          if config[:short]
+            it 'suggests valid values for short form with invalid value' do
+              expect_error_output(
+                error: error,
+                argv: [config[:short], 'xyz'],
+                pattern: config[:pattern]
+              )
+            end
+          end
+        end
+      end
+
+      context 'for --stale option edge cases' do
+        it 'suggests valid values when value is missing' do
+          error = OptionParser::InvalidArgument.new('missing argument: --stale')
+          expect_error_output(
+            error: error,
+            argv: ['--stale'],
+            pattern: /Valid values for --stale: o\[ff\]|e\[rror\]/
+          )
+        end
+
+        it 'suggests valid values when next token looks like an option' 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\]/
+          )
+        end
+      end
+    end
+
+    context 'with multiple options in argv' do
+      it 'correctly identifies the problematic option among valid options' 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\]/
+        )
+      end
+
+      it 'handles equal form mixed with other options' do
+        error = OptionParser::InvalidArgument.new('invalid argument: invalid')
+        expect_error_output(
+          error: error,
+          argv: ['--json', '--sort-order=invalid', '--resultset', 'coverage'],
+          pattern: /Valid values for --sort-order: a\[scending\]|d\[escending\]/
+        )
+      end
+    end
+
+    context 'when option is not an enumerated type' do
+      it 'shows generic error message without enum hint' do
+        error = OptionParser::InvalidArgument.new('invalid option: --unknown')
+
+        stderr_output = capture_stderr do
+          helper.handle_option_parser_error(error, argv: ['--unknown'])
+        end
+
+        expect(stderr_output).to match(/Error:.*invalid option.*--unknown/)
+        expect(stderr_output).to match(/Run 'simplecov-mcp --help'/)
+        expect(stderr_output).not_to match(/Valid values/)
+      end
+    end
+
+    context 'when invalid option matches a subcommand' do
+      it 'suggests using it as a subcommand instead' do
+        error = OptionParser::InvalidOption.new('invalid option: --summary')
+
+        stderr_output = capture_stderr do
+          helper.handle_option_parser_error(error, argv: ['--summary'])
+        end
+
+        # 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
+      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)
+        end
+      end
+    end
+
+    context 'usage hint customization' 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
+        end.to output(/Custom hint message/).to_stderr
+      end
+    end
+  end
+
+  describe 'edge cases' do
+    it 'handles empty argv gracefully' do
+      error = OptionParser::InvalidArgument.new('some error')
+      expect_error_output(
+        error: error,
+        argv: [],
+        pattern: /Error: invalid argument: some error/
+      )
+    end
+
+    it 'handles argv with only valid options (no problematic enum)' do
+      error = OptionParser::InvalidArgument.new('some error')
+
+      stderr_output = capture_stderr do
+        helper.handle_option_parser_error(error, argv: ['--json', '--resultset', 'coverage'])
+      end
+
+      expect(stderr_output).to match(/Error: invalid argument: some error/)
+      expect(stderr_output).to match(/Run 'simplecov-mcp --help'/)
+    end
+
+    it 'does not show enum hint when all enum values are valid' do
+      error = OptionParser::MissingArgument.new('missing argument: --resultset')
+
+      stderr_output = capture_stderr do
+        helper.handle_option_parser_error(error, argv: ['--stale', 'off', '--resultset'])
+      end
+
+      expect(stderr_output).to match(/Error:.*missing argument.*--resultset/)
+      expect(stderr_output).not_to match(/Valid values/)
+    end
+  end
+end

data/spec/path_relativizer_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::PathRelativizer do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:relativizer) do
+    described_class.new(
+      root: root,
+      scalar_keys: %w[file file_path],
+      array_keys: %w[newer_files missing_files deleted_files]
+    )
+  end
+
+  describe '#relativize' do
+    it 'converts configured scalar keys to root-relative paths' do
+      payload = { 'file' => File.join(root, 'lib/foo.rb') }
+      result = relativizer.relativize(payload)
+
+      expect(result['file']).to eq('lib/foo.rb')
+      expect(payload['file']).to eq(File.join(root, 'lib/foo.rb'))
+    end
+
+    it 'relativizes arrays for configured keys without mutating originals' do
+      payload = {
+        'newer_files' => [File.join(root, 'lib/foo.rb'), File.join(root, 'lib/bar.rb')]
+      }
+
+      result = relativizer.relativize(payload)
+
+      expect(result['newer_files']).to contain_exactly('lib/foo.rb', 'lib/bar.rb')
+      expect(payload['newer_files']).to all(start_with(root))
+    end
+
+    it 'leaves unconfigured keys untouched' do
+      payload = { 'other' => File.join(root, 'lib/foo.rb') }
+      result = relativizer.relativize(payload)
+
+      expect(result['other']).to eq(payload['other'])
+    end
+
+    it 'ignores paths outside the root' do
+      outside = '/tmp/external.rb'
+      payload = { 'file' => outside }
+
+      result = relativizer.relativize(payload)
+
+      expect(result['file']).to eq(outside)
+    end
+
+    it 'relativizes nested arrays of hashes' do
+      payload = {
+        'files' => [
+          { 'file' => File.join(root, 'lib/foo.rb') },
+          { 'file' => File.join(root, 'lib/bar.rb') }
+        ],
+        'counts' => { 'total' => 2 }
+      }
+
+      result = relativizer.relativize(payload)
+
+      expect(result['files'].map { |h| h['file'] }).to eq(%w[lib/foo.rb lib/bar.rb])
+      expect(result['counts']).to eq('total' => 2)
+    end
+
+    it "handles paths with '..' components" do
+      payload = { 'file' => File.join(root, 'lib/../lib/foo.rb') }
+      result = relativizer.relativize(payload)
+      expect(result['file']).to eq('lib/foo.rb')
+    end
+
+    it 'handles paths with spaces' do
+      file_with_space = File.join(root, 'lib/file with space.rb')
+      FileUtils.touch(file_with_space)
+
+      payload = { 'file' => file_with_space }
+      result = relativizer.relativize(payload)
+      expect(result['file']).to eq('lib/file with space.rb')
+    ensure
+      FileUtils.rm_f(file_with_space)
+    end
+  end
+end

data/spec/presenters/coverage_detailed_presenter_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../shared_examples/coverage_presenter_examples'
+
+RSpec.describe SimpleCovMcp::Presenters::CoverageDetailedPresenter do
+  it_behaves_like 'a coverage presenter',
+    model_method: :detailed_for,
+    payload: {
+      'file' => '/abs/path/lib/foo.rb',
+      'lines' => [
+        { 'line' => 1, 'hits' => 1, 'covered' => true },
+        { 'line' => 2, 'hits' => 0, 'covered' => false }
+      ],
+      'summary' => { 'covered' => 1, 'total' => 2, 'pct' => 50.0 }
+    },
+    stale: 'L',
+    expected_keys: ['lines', 'summary']
+end

data/spec/presenters/coverage_raw_presenter_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../shared_examples/coverage_presenter_examples'
+
+RSpec.describe SimpleCovMcp::Presenters::CoverageRawPresenter do
+  it_behaves_like 'a coverage presenter',
+    model_method: :raw_for,
+    payload: {
+      'file' => '/abs/path/lib/foo.rb',
+      'lines' => [1, 0, nil, 2]
+    },
+    stale: 'L',
+    expected_keys: ['lines']
+end

data/spec/presenters/coverage_summary_presenter_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../shared_examples/coverage_presenter_examples'
+
+RSpec.describe SimpleCovMcp::Presenters::CoverageSummaryPresenter do
+  it_behaves_like 'a coverage presenter',
+    model_method: :summary_for,
+    payload: {
+      'file' => '/abs/path/lib/foo.rb',
+      'summary' => { 'covered' => 8, 'total' => 10, 'pct' => 80.0 }
+    },
+    stale: false,
+    expected_keys: ['summary']
+end

data/spec/presenters/coverage_uncovered_presenter_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../shared_examples/coverage_presenter_examples'
+
+RSpec.describe SimpleCovMcp::Presenters::CoverageUncoveredPresenter do
+  it_behaves_like 'a coverage presenter',
+    model_method: :uncovered_for,
+    payload: {
+      'file' => '/abs/path/lib/foo.rb',
+      'uncovered' => [2, 4],
+      'summary' => { 'covered' => 2, 'total' => 4, 'pct' => 50.0 }
+    },
+    stale: 'M',
+    expected_keys: ['uncovered', 'summary']
+end

data/spec/presenters/project_coverage_presenter_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::Presenters::ProjectCoveragePresenter do
+  let(:model) { instance_double(SimpleCovMcp::CoverageModel) }
+  let(:sort_order) { :ascending }
+  let(:check_stale) { true }
+  let(:tracked_globs) { ['lib/**/*.rb'] }
+  let(:files) do
+    [
+      {
+        'file' => '/abs/path/lib/foo.rb',
+        'covered' => 5,
+        'total' => 6,
+        'percentage' => 83.33,
+        'stale' => false
+      },
+      {
+        'file' => '/abs/path/lib/bar.rb',
+        'covered' => 1,
+        'total' => 6,
+        'percentage' => 16.67,
+        'stale' => 'L'
+      }
+    ]
+  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,
+      tracked_globs: tracked_globs).and_return(files)
+    allow(model).to receive(:relativize) do |payload|
+      relativizer = SimpleCovMcp::PathRelativizer.new(
+        root: '/abs/path',
+        scalar_keys: %w[file file_path],
+        array_keys: %w[newer_files missing_files deleted_files]
+      )
+      relativizer.relativize(payload)
+    end
+  end
+
+  describe '#absolute_payload' do
+    it 'returns files and counts with stale metadata' do
+      payload = presenter.absolute_payload
+
+      expect(payload['files']).to eq(files)
+      expect(payload['counts']).to eq({ 'total' => 2, 'ok' => 1, 'stale' => 1 })
+    end
+
+    it 'memoizes the computed payload' do
+      presenter.absolute_payload
+      presenter.absolute_payload
+
+      expect(model).to have_received(:all_files).once
+    end
+  end
+
+  describe '#relativized_payload' do
+    it 'relativizes the files list' do
+      relativized = presenter.relativized_payload
+
+      expect(relativized['files'].map { |f| f['file'] }).to eq(['lib/foo.rb', 'lib/bar.rb'])
+    end
+  end
+
+  describe '#relative_files' do
+    it 'returns the relativized file list' do
+      expect(presenter.relative_files.map { |f| f['file'] }).to eq(['lib/foo.rb', 'lib/bar.rb'])
+    end
+  end
+
+  describe '#relative_counts' do
+    it 'returns the relativized counts hash' do
+      expect(presenter.relative_counts).to eq({ 'total' => 2, 'ok' => 1, 'stale' => 1 })
+    end
+  end
+end

data/spec/resolvers/coverage_line_resolver_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+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
+            }
+          }
+        }
+      }
+
+      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
+  end
+end

data/spec/resolvers/resolver_factory_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+
+RSpec.describe SimpleCovMcp::Resolvers::ResolverFactory do
+  describe '.create_resultset_resolver' do
+    it 'uses provided candidates when present' do
+      custom_candidates = ['alt/.resultset.json']
+      resolver = described_class.create_resultset_resolver(
+        root: '/tmp/sample',
+        candidates: custom_candidates
+      )
+
+      expect(resolver).to be_a(SimpleCovMcp::Resolvers::ResultsetPathResolver)
+      expect(resolver.instance_variable_get(:@root)).to eq('/tmp/sample')
+      expect(resolver.instance_variable_get(:@candidates)).to eq(custom_candidates)
+    end
+
+    it 'falls back to default candidates when none provided' do
+      resolver = described_class.create_resultset_resolver(root: '/tmp/sample')
+
+      expect(resolver.instance_variable_get(:@candidates)).to eq(
+        SimpleCovMcp::Resolvers::ResultsetPathResolver::DEFAULT_CANDIDATES
+      )
+    end
+  end
+
+  describe '.create_coverage_resolver' do
+    it 'wraps coverage data in a CoverageLineResolver' do
+      cov = { '/tmp/foo.rb' => { 'lines' => [1, 0] } }
+      resolver = described_class.create_coverage_resolver(cov)
+
+      expect(resolver).to be_a(SimpleCovMcp::Resolvers::CoverageLineResolver)
+      expect(resolver.lookup_lines('/tmp/foo.rb')).to eq([1, 0])
+    end
+  end
+
+  describe '.find_resultset' do
+    it 'locates default resultset within the provided root' do
+      Dir.mktmpdir do |dir|
+        resultset_path = File.join(dir, '.resultset.json')
+        File.write(resultset_path, '{}')
+
+        resolved = described_class.find_resultset(dir)
+
+        expect(resolved).to eq(resultset_path)
+      end
+    end
+  end
+
+  describe '.lookup_lines' do
+    it 'delegates to CoverageLineResolver for lookups' do
+      cov = { '/tmp/bar.rb' => { 'lines' => [0, 1] } }
+
+      expect(
+        described_class.lookup_lines(cov, '/tmp/bar.rb')
+      ).to eq([0, 1])
+    end
+  end
+end

data/spec/resolvers/resultset_path_resolver_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+
+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(:resolver) { described_class.new(root: root) }
+
+    it 'raises when a specified resultset file cannot be found' do
+      expect do
+        resolver.find_resultset(resultset: 'missing.json')
+      end.to raise_error(RuntimeError, /Specified resultset not found/)
+    end
+
+    it 'raises when a specified directory does not contain .resultset.json' do
+      nested_dir = File.join(root, 'coverage')
+      Dir.mkdir(nested_dir)
+
+      expect do
+        resolver.find_resultset(resultset: nested_dir)
+      end.to raise_error(RuntimeError, /No .resultset.json found in directory/)
+    end
+
+    it 'returns the resolved path when a valid resultset file is provided' do
+      file = File.join(root, 'custom.json')
+      File.write(file, '{}')
+
+      expect(resolver.find_resultset(resultset: file)).to eq(file)
+    end
+
+    it 'raises a helpful error when no fallback candidates are found' do
+      expect do
+        resolver.find_resultset
+      end.to raise_error(RuntimeError, /Could not find .resultset.json/)
+    end
+
+    it 'accepts a resultset path already nested under the provided root without double-prefixing' do
+      project_root = (FIXTURES_DIR / 'project1').to_s
+      resolver = described_class.new(root: project_root)
+
+      resolved = resolver.find_resultset(resultset: 'spec/fixtures/project1/coverage')
+
+      expect(resolved).to eq(File.join(project_root, 'coverage', '.resultset.json'))
+    end
+  end
+end