simplecov-mcp 0.3.0 → 1.0.0

data/spec/simplecov_mcp_model_spec.rb

@@ -3,9 +3,29 @@
 require 'spec_helper'
 
 RSpec.describe SimpleCovMcp::CoverageModel do
-  let(:root)  { (FIXTURES / 'project1').to_s }
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
   subject(:model) { described_class.new(root: root) }
 
+  describe 'initialization error handling' do
+    it 'raises FileError when File.read raises Errno::ENOENT directly' do
+      # Stub find_resultset to return a path, but File.read to raise ENOENT
+      allow(SimpleCovMcp::CovUtil).to receive(:find_resultset)
+        .and_return('/some/path/.resultset.json')
+      allow(File).to receive(:read).with('/some/path/.resultset.json')
+        .and_raise(Errno::ENOENT, 'No such file')
+
+      expect do
+        described_class.new(root: root, resultset: '/some/path/.resultset.json')
+      end.to raise_error(SimpleCovMcp::FileError, /Coverage data not found/)
+    end
+
+    it 'raises CoverageDataError when resultset file does not exist' do
+      expect do
+        described_class.new(root: root, resultset: '/nonexistent/path/.resultset.json')
+      end.to raise_error(SimpleCovMcp::CoverageDataError, /Failed to load coverage data/)
+    end
+  end
+
   describe 'raw_for' do
     it 'returns absolute file and lines array' do
       data = model.raw_for('lib/foo.rb')
@@ -23,6 +43,17 @@ RSpec.describe SimpleCovMcp::CoverageModel do
     end
   end
 
+  describe '#relativize' do
+    it 'returns a copy with file paths relative to the root' do
+      data = model.summary_for('lib/foo.rb')
+      relative = model.relativize(data)
+
+      expect(relative['file']).to eq('lib/foo.rb')
+      expect(data['file']).not_to eq(relative['file'])
+      expect(relative).not_to equal(data)
+    end
+  end
+
   describe 'uncovered_for' do
     it 'lists uncovered executable line numbers' do
       data = model.uncovered_for('lib/foo.rb')
@@ -42,6 +73,36 @@ RSpec.describe SimpleCovMcp::CoverageModel do
     end
   end
 
+  describe 'staleness_for' do
+    it 'returns the staleness character for a file' do
+      allow_any_instance_of(SimpleCovMcp::StalenessChecker)
+        .to receive(:stale_for_file?) do |_, file_abs, _|
+          if file_abs == File.expand_path('lib/foo.rb', root)
+            'T'
+          else
+            false
+          end
+        end
+
+      expect(model.staleness_for('lib/foo.rb')).to eq('T')
+      expect(model.staleness_for('lib/bar.rb')).to eq(false)
+    end
+
+    it 'returns false when an exception occurs during staleness check' do
+      # Stub the checker to raise an error
+      allow_any_instance_of(SimpleCovMcp::StalenessChecker).to receive(:stale_for_file?)
+        .and_raise(StandardError, 'Something went wrong')
+
+      # The rescue clause should catch the error and return false
+      expect(model.staleness_for('lib/foo.rb')).to eq(false)
+    end
+
+    it 'returns false when coverage data is not found for the file' do
+      # Try to get staleness for a file that doesn't exist in coverage
+      expect(model.staleness_for('lib/nonexistent.rb')).to eq(false)
+    end
+  end
+
   describe 'all_files' do
     it 'sorts ascending by percentage then by file path' do
       files = model.all_files(sort_order: :ascending)
@@ -49,6 +110,70 @@ RSpec.describe SimpleCovMcp::CoverageModel do
       expect(files.first['percentage']).to be_within(0.01).of(33.33)
       expect(files.last['file']).to eq(File.expand_path('lib/foo.rb', root))
     end
+
+    it 'filters rows when tracked_globs are provided' do
+      files = model.all_files(tracked_globs: ['lib/foo.rb'])
+
+      expect(files.length).to eq(1)
+      expect(files.first['file']).to eq(File.expand_path('lib/foo.rb', root))
+    end
+
+    it 'combines results from multiple tracked_globs patterns' do
+      abs_bar = File.expand_path('lib/bar.rb', root)
+
+      files = model.all_files(tracked_globs: ['lib/foo.rb', abs_bar])
+
+      expect(files.map { |f| f['file'] }).to contain_exactly(
+        File.expand_path('lib/foo.rb', root),
+        abs_bar
+      )
+    end
+
+    it 'handles files with paths that cannot be relativized' do
+      # Create a custom row with a path from a Windows-style drive (C:/) that will cause ArgumentError
+      # when trying to make it relative to a Unix-style root
+      custom_rows = [
+        {
+          'file' => 'C:/Windows/system32/file.rb',
+          'percentage' => 100.0,
+          'covered' => 10,
+          'total' => 10,
+          'stale' => false
+        }
+      ]
+
+      # This should trigger the ArgumentError rescue in filter_rows_by_globs
+      # When the path cannot be made relative (different path types), it falls back to using the absolute path
+      output = model.format_table(custom_rows, tracked_globs: ['C:/Windows/**/*.rb'])
+
+      # The file should be included because the absolute path fallback matches the glob
+      expect(output).to include('C:/Windows/system32/file.rb')
+    end
+  end
+
+  describe 'resolve method error handling' do
+    it 'raises FileError when coverage_lines is nil after lookup' do
+      # Stub lookup_lines to return nil without raising
+      allow(SimpleCovMcp::CovUtil).to receive(:lookup_lines).and_return(nil)
+
+      expect do
+        model.summary_for('lib/nonexistent.rb')
+      end.to raise_error(SimpleCovMcp::FileError, /No coverage data found for file/)
+    end
+
+    it 'converts Errno::ENOENT to FileNotFoundError during resolve' do
+      # We need to trigger Errno::ENOENT inside the resolve method
+      # Stub the checker's check_file! method to raise Errno::ENOENT
+      allow_any_instance_of(SimpleCovMcp::StalenessChecker).to receive(:check_file!)
+        .and_raise(Errno::ENOENT, 'No such file or directory')
+
+      # Create a model with staleness checking enabled to trigger the check_file! call
+      stale_model = described_class.new(root: root, staleness: 'error')
+
+      expect do
+        stale_model.summary_for('lib/foo.rb')
+      end.to raise_error(SimpleCovMcp::FileNotFoundError, /File not found/)
+    end
   end
 
   describe 'resultset directory handling' do
@@ -58,16 +183,222 @@ RSpec.describe SimpleCovMcp::CoverageModel do
       expect(data['summary']['total']).to eq(3)
       expect(data['summary']['covered']).to eq(2)
     end
+  end
+
+  describe 'branch-only coverage resultsets' do
+    let(:branch_root) { (FIXTURES_DIR / 'branch_only_project').to_s }
+    let(:branch_model) { described_class.new(root: branch_root) }
+
+    it 'computes summaries by synthesizing branch data' do
+      data = branch_model.summary_for('lib/branch_only.rb')
+
+      expect(data['summary']['total']).to eq(5)
+      expect(data['summary']['covered']).to eq(3)
+      expect(data['summary']['pct']).to be_within(0.01).of(60.0)
+    end
+
+    it 'returns detailed data using branch-derived hits' do
+      data = branch_model.detailed_for('lib/branch_only.rb')
+
+      expect(data['lines']).to eq([
+        { 'line' => 6,  'hits' => 3, 'covered' => true },
+        { 'line' => 7,  'hits' => 0, 'covered' => false },
+        { 'line' => 13, 'hits' => 0, 'covered' => false },
+        { 'line' => 14, 'hits' => 2, 'covered' => true },
+        { 'line' => 16, 'hits' => 2, 'covered' => true }
+      ])
+    end
+
+    it 'identifies uncovered lines based on branch hits' do
+      data = branch_model.uncovered_for('lib/branch_only.rb')
+
+      expect(data['uncovered']).to eq([7, 13])
+    end
+
+    it 'includes branch-only files in all_files results' do
+      files = branch_model.all_files(sort_order: :ascending)
+      branch_path = File.expand_path('lib/branch_only.rb', branch_root)
+      another_path = File.expand_path('lib/another.rb', branch_root)
+
+      expect(files.map { |f| f['file'] }).to contain_exactly(branch_path, another_path)
+
+      branch_entry = files.find { |f| f['file'] == branch_path }
+      another_entry = files.find { |f| f['file'] == another_path }
+
+      expect(branch_entry['total']).to eq(5)
+      expect(branch_entry['covered']).to eq(3)
+      expect(another_entry['total']).to eq(1)
+      expect(another_entry['covered']).to eq(0)
+    end
+  end
+
+  describe 'multiple suites in resultset' do
+    let(:resultset_path) { '/tmp/multi_suite_resultset.json' }
+
+    before do
+      allow(SimpleCovMcp::CovUtil).to receive(:find_resultset).and_wrap_original do
+        |original, search_root, resultset: nil|
+        root_match = File.absolute_path(search_root) == File.absolute_path(root)
+        resultset_empty = resultset.nil? || resultset.to_s.empty?
+        if root_match && resultset_empty
+          resultset_path
+        else
+          original.call(search_root, resultset: resultset)
+        end
+      end
+      allow(File).to receive(:read).and_call_original
+    end
+
+    it 'merges coverage data from multiple suites while keeping latest timestamp' do
+      suite_a_cov = {
+        File.join(root, 'lib', 'foo.rb') => { 'lines' => [1, 0, nil, 2] }
+      }
+      suite_b_cov = {
+        File.join(root, 'lib', 'bar.rb') => { 'lines' => [0, 1, 1] }
+      }
+
+      resultset = {
+        'RSpec' => { 'timestamp' => 100, 'coverage' => suite_a_cov },
+        'Cucumber' => { 'timestamp' => 200, 'coverage' => suite_b_cov }
+      }
+
+      allow(File).to receive(:read).with(resultset_path).and_return(resultset.to_json)
+
+      model = described_class.new(root: root)
+      files = model.all_files(sort_order: :ascending)
+
+      expect(files.map { |f| File.basename(f['file']) }).to include('foo.rb', 'bar.rb')
+
+      timestamp = model.instance_variable_get(:@cov_timestamp)
+      expect(timestamp).to eq(200)
+    end
+
+    it 'combines coverage arrays when the same file appears in multiple suites' do
+      shared_file = File.join(root, 'lib', 'foo.rb')
+      suite_a_cov = {
+        shared_file => { 'lines' => [1, 0, nil, 0] }
+      }
+      suite_b_cov = {
+        shared_file => { 'lines' => [0, 3, nil, 1] }
+      }
+
+      resultset = {
+        'RSpec' => { 'timestamp' => 100, 'coverage' => suite_a_cov },
+        'Cucumber' => { 'timestamp' => 150, 'coverage' => suite_b_cov }
+      }
 
-    it 'uses SIMPLECOV_RESULTSET when it is a directory' do
-      begin
-        ENV['SIMPLECOV_RESULTSET'] = 'coverage'
-        model = described_class.new(root: root)
-        data = model.summary_for('lib/foo.rb')
-        expect(data['summary']['covered']).to eq(2)
-      ensure
-        ENV.delete('SIMPLECOV_RESULTSET')
+      allow(File).to receive(:read).with(resultset_path).and_return(resultset.to_json)
+
+      model = described_class.new(root: root)
+      detailed = model.detailed_for('lib/foo.rb')
+      hits_by_line = detailed['lines'].each_with_object({}) do |row, acc|
+        acc[row['line']] = row['hits']
       end
+
+      expect(hits_by_line[1]).to eq(1)
+      expect(hits_by_line[2]).to eq(3)
+      expect(hits_by_line[4]).to eq(1)
+    end
+  end
+
+  describe 'format_table' do
+    it 'returns a formatted table string with all files coverage data' do
+      output = model.format_table
+
+      # Should contain table structure
+      expect(output).to include('┌', '┬', '┐', '│', '├', '┼', '┤', '└', '┴', '┘')
+
+      # Should contain headers
+      expect(output).to include('File', '%', 'Covered', 'Total', 'Stale')
+
+      # Should contain file data
+      expect(output).to include('lib/foo.rb', 'lib/bar.rb')
+
+      # Should contain summary
+      expect(output).to include('Files: total', ', ok ', ', stale ')
+    end
+
+    it 'returns "No coverage data found" when rows is empty' do
+      rows = []
+      output = model.format_table(rows)
+      expect(output).to eq('No coverage data found')
+    end
+
+    it 'accepts custom rows parameter' do
+      custom_rows = [
+        {
+          'file' => '/path/to/file1.rb',
+          'percentage' => 100.0,
+          'covered' => 10,
+          'total' => 10,
+          'stale' => false
+        },
+        {
+          'file' => '/path/to/file2.rb',
+          'percentage' => 50.0,
+          'covered' => 5,
+          'total' => 10,
+          'stale' => 'M'
+        },
+        {
+          'file' => '/path/to/file3.rb',
+          'percentage' => 75.0,
+          'covered' => 15,
+          'total' => 20,
+          'stale' => 'T'
+        }
+      ]
+
+      output = model.format_table(custom_rows)
+
+      expect(output).to include('file1.rb')
+      expect(output).to include('file2.rb')
+      expect(output).to include('file3.rb')
+      expect(output).to include('100.00')
+      expect(output).to include('50.00')
+      expect(output).to include('75.00')
+      expect(output).to include('M')
+      expect(output).to include('T')
+      expect(output).not_to include('!')
+      staleness_msg = 'Staleness: M = Missing file, T = Timestamp (source newer), ' \
+                      'L = Line count mismatch'
+      expect(output).to include(staleness_msg)
+    end
+
+    it 'accepts sort_order parameter' do
+      # Test that sort_order parameter is passed through correctly
+      rows_desc = model.all_files(sort_order: :descending)
+      output_asc = model.format_table(sort_order: :ascending)
+      output_desc = model.format_table(sort_order: :descending)
+
+      # Both should be valid table outputs
+      expect(output_asc).to include('┌')
+      expect(output_desc).to include('┌')
+      expect(output_asc).to include('Files: total')
+      expect(output_desc).to include('Files: total')
+    end
+
+    it 'sorts table output correctly when provided with custom rows' do
+      # Get all files data to use as custom rows
+      all_files_data = model.all_files
+
+      # Test ascending sort with custom rows
+      output_asc = model.format_table(all_files_data, sort_order: :ascending)
+      lines_asc = output_asc.split("\n")
+      bar_line_asc = lines_asc.find { |line| line.include?('bar.rb') }
+      foo_line_asc = lines_asc.find { |line| line.include?('foo.rb') }
+
+      # In ascending order, bar.rb (33.33%) should come before foo.rb (66.67%)
+      expect(lines_asc.index(bar_line_asc)).to be < lines_asc.index(foo_line_asc)
+
+      # Test descending sort with custom rows
+      output_desc = model.format_table(all_files_data, sort_order: :descending)
+      lines_desc = output_desc.split("\n")
+      bar_line_desc = lines_desc.find { |line| line.include?('bar.rb') }
+      foo_line_desc = lines_desc.find { |line| line.include?('foo.rb') }
+
+      # In descending order, foo.rb (66.67%) should come before bar.rb (33.33%)
+      expect(lines_desc.index(foo_line_desc)).to be < lines_desc.index(bar_line_desc)
     end
   end
 end

data/spec/simplecov_mcp_opts_spec.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'SIMPLECOV_MCP_OPTS Environment Variable' do
+  let(:cli) { SimpleCovMcp::CoverageCLI.new }
+
+  around do |example|
+    original_value = ENV['SIMPLECOV_MCP_OPTS']
+    example.run
+  ensure
+    ENV['SIMPLECOV_MCP_OPTS'] = original_value
+  end
+
+  describe 'CLI option parsing from environment' do
+    it 'parses simple options from SIMPLECOV_MCP_OPTS' do
+      ENV['SIMPLECOV_MCP_OPTS'] = '--error-mode off --json'
+
+      begin
+        silence_output { cli.send(:run, ['summary', 'lib/foo.rb']) }
+      rescue Exception => e
+        # Expected to fail due to missing file, but options should be parsed
+        puts "DEBUG: Caught exception: #{e.class}: #{e.message}" if ENV['DEBUG']
+      end
+
+      expect(cli.config.error_mode).to eq(:off)
+      expect(cli.config.json).to be true
+    end
+
+    it 'handles quoted options with spaces' do
+      test_path = File.join(Dir.tmpdir, 'test path with spaces', '.resultset.json')
+      ENV['SIMPLECOV_MCP_OPTS'] = "--resultset \"#{test_path}\""
+
+      # Stub exit method to prevent process termination
+      allow_any_instance_of(Object).to receive(:exit)
+
+      # silence_output captures the expected error message from the CLI trying to
+      # load the (non-existent) resultset, preventing it from leaking to the console.
+      silence_output do
+        cli.send(:run, ['--help'])
+      end
+
+      expect(cli.config.resultset).to eq(test_path)
+    end
+
+    it 'supports setting log-file to stdout from environment' do
+      ENV['SIMPLECOV_MCP_OPTS'] = '--log-file stdout'
+
+      allow_any_instance_of(Object).to receive(:exit)
+
+      silence_output do
+        cli.send(:run, ['--help'])
+      end
+
+      expect(cli.config.log_file).to eq('stdout')
+    end
+
+    it 'command line arguments override environment options' do
+      ENV['SIMPLECOV_MCP_OPTS'] = '--error-mode off'
+
+      begin
+        silence_output { cli.send(:run, ['--error-mode', 'trace', 'summary', 'lib/foo.rb']) }
+      rescue SystemExit, SimpleCovMcp::Error
+        # Expected to fail, but options should be parsed
+      end
+
+      # Command line should override environment
+      expect(cli.config.error_mode).to eq(:trace)
+    end
+
+    it 'handles malformed SIMPLECOV_MCP_OPTS gracefully' do
+      ENV['SIMPLECOV_MCP_OPTS'] = '--option "unclosed quote'
+
+      # Should catch the ConfigurationError and exit cleanly
+      _out, _err, status = run_cli_with_status('summary', 'lib/foo.rb')
+      expect(status).not_to eq(0)
+    end
+
+    it 'returns empty array when SIMPLECOV_MCP_OPTS is not set' do
+      # ENV is already cleared by around block
+      opts = cli.send(:parse_env_opts)
+      expect(opts).to eq([])
+    end
+
+    it 'returns empty array when SIMPLECOV_MCP_OPTS is empty' do
+      ENV['SIMPLECOV_MCP_OPTS'] = ''
+      opts = cli.send(:parse_env_opts)
+      expect(opts).to eq([])
+    end
+  end
+
+  describe 'CLI mode detection with SIMPLECOV_MCP_OPTS' do
+    it 'respects --force-cli from environment variable' do
+      ENV['SIMPLECOV_MCP_OPTS'] = '--force-cli'
+
+      # This would normally be MCP mode (no TTY, no subcommand)
+      stdin = double('stdin', tty?: false)
+
+      env_opts = SimpleCovMcp.send(:parse_env_opts_for_mode_detection)
+      full_argv = env_opts + []
+
+      expect(SimpleCovMcp::ModeDetector.cli_mode?(full_argv, stdin: stdin)).to be true
+    end
+
+    it 'handles parse errors gracefully in mode detection' do
+      ENV['SIMPLECOV_MCP_OPTS'] = '--option "unclosed quote'
+
+      # Should return empty array and not crash
+      opts = SimpleCovMcp.send(:parse_env_opts_for_mode_detection)
+      expect(opts).to eq([])
+    end
+
+    it 'actually runs CLI when --force-cli is in SIMPLECOV_MCP_OPTS' do
+      ENV['SIMPLECOV_MCP_OPTS'] = '--force-cli'
+
+      # Mock STDIN to not be a TTY (would normally trigger MCP server mode)
+      allow(STDIN).to receive(:tty?).and_return(false)
+
+      # Stub exit to prevent process termination
+      allow_any_instance_of(Object).to receive(:exit)
+
+      # Run with --help which should produce help output
+      output = nil
+      silence_output do |out, err|
+        SimpleCovMcp.run(['--help'])
+        output = out.string + err.string
+      end
+
+      # Verify CLI actually ran by checking for help text
+      expect(output).to include('Usage:')
+      expect(output).to include('simplecov-mcp')
+    end
+
+    it 'actually runs MCP server mode when no CLI indicators present' do
+      ENV['SIMPLECOV_MCP_OPTS'] = ''
+
+      # Mock STDIN to not be a TTY and to provide valid JSON-RPC
+      allow(STDIN).to receive(:tty?).and_return(false)
+
+      # Provide a minimal JSON-RPC request that the server can handle
+      json_request = JSON.generate({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: '2024-11-05',
+          capabilities: {},
+          clientInfo: { name: 'test', version: '1.0' }
+        }
+      })
+
+      allow(STDIN).to receive(:gets).and_return(json_request, nil)
+
+      # Capture output to verify MCP server response
+      output = nil
+      silence_output do |out, err|
+        SimpleCovMcp.run([])
+        output = out.string + err.string
+      end
+
+      # Verify MCP server ran by checking for JSON-RPC response
+      expect(output).to include('"jsonrpc"')
+      expect(output).to include('"result"')
+    end
+  end
+
+  describe 'integration with actual CLI usage' do
+    it 'works end-to-end with --resultset option' do
+      test_resultset = File.join(Dir.tmpdir, 'test_coverage', '.resultset.json')
+      ENV['SIMPLECOV_MCP_OPTS'] = "--resultset #{test_resultset} --json"
+
+      allow_any_instance_of(Object).to receive(:exit)
+
+      expect do
+        silence_output { cli.send(:run, ['--help']) }
+      end.not_to raise_error
+
+      expect(cli.config.resultset).to eq(test_resultset)
+      expect(cli.config.json).to be true
+    end
+  end
+end