simplecov-mcp 1.0.1 → 2.0.1

data/spec/commands/validate_command_spec.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tempfile'
+
+RSpec.describe SimpleCovMcp::Commands::ValidateCommand do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+
+  def with_temp_predicate(content)
+    Tempfile.create(['predicate', '.rb']) do |file|
+      file.write(content)
+      file.flush
+      yield file.path
+    end
+  end
+
+  describe 'validate subcommand with file' do
+    it 'exits 0 when predicate returns truthy value' do
+      with_temp_predicate("->(model) { true }\n") do |path|
+        _out, _err, status = run_cli_with_status(
+          '--root', root,
+          '--resultset', 'coverage',
+          'validate', path
+        )
+        expect(status).to eq(0)
+      end
+    end
+
+    it 'exits 1 when predicate returns falsy value' do
+      with_temp_predicate("->(model) { false }\n") do |path|
+        _out, _err, status = run_cli_with_status(
+          '--root', root,
+          '--resultset', 'coverage',
+          'validate', path
+        )
+        expect(status).to eq(1)
+      end
+    end
+
+    it 'exits 2 when predicate raises an error' do
+      with_temp_predicate("->(model) { raise 'Boom!' }\n") do |path|
+        _out, err, status = run_cli_with_status(
+          '--root', root,
+          '--resultset', 'coverage',
+          'validate', path
+        )
+        expect(status).to eq(2)
+        expect(err).to include('Predicate error: Boom!')
+      end
+    end
+
+    it 'shows backtrace when predicate errors with --error-mode debug' do
+      with_temp_predicate("->(model) { raise 'Boom!' }\n") do |path|
+        _out, err, status = run_cli_with_status(
+          '--error-mode', 'debug',
+          '--root', root,
+          '--resultset', 'coverage',
+          'validate', path
+        )
+        expect(status).to eq(2)
+        expect(err).to include('Predicate error: Boom!')
+        # With trace mode, should show backtrace
+        expect(err).to match(/predicate.*\.rb:\d+/)
+      end
+    end
+
+    it 'exits 2 when predicate file is not found' do
+      _out, err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '/nonexistent/predicate.rb'
+      )
+      expect(status).to eq(2)
+      expect(err).to include('Predicate file not found')
+    end
+
+    it 'exits 2 when predicate has syntax error' do
+      with_temp_predicate("-> { this is invalid syntax\n") do |path|
+        _out, err, status = run_cli_with_status(
+          '--root', root,
+          '--resultset', 'coverage',
+          'validate', path
+        )
+        expect(status).to eq(2)
+        expect(err).to include('Syntax error in predicate file')
+      end
+    end
+
+    it 'exits 2 when predicate is not callable' do
+      with_temp_predicate("42\n") do |path|
+        _out, err, status = run_cli_with_status(
+          '--root', root,
+          '--resultset', 'coverage',
+          'validate', path
+        )
+        expect(status).to eq(2)
+        expect(err).to include('Predicate must be callable')
+      end
+    end
+
+    it 'provides model to predicate that can query coverage' do
+      # Test that the predicate receives a working CoverageModel
+      with_temp_predicate(<<~RUBY) do |path|
+        ->(model) do
+          # Access coverage data via the model
+          summary = model.summary_for('lib/foo.rb')
+          summary['summary']['percentage'] > 50  # Should be true for foo.rb
+        end
+      RUBY
+        _out, _err, status = run_cli_with_status(
+          '--root', root,
+          '--resultset', 'coverage',
+          'validate', path
+        )
+        expect(status).to eq(0)
+      end
+    end
+  end
+
+  describe 'validate subcommand with -i/--inline flag' do
+    it 'exits 0 when predicate code returns truthy value' do
+      _out, _err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '-i', '->(model) { true }'
+      )
+      expect(status).to eq(0)
+    end
+
+    it 'exits 1 when predicate code returns falsy value' do
+      _out, _err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '-i', '->(model) { false }'
+      )
+      expect(status).to eq(1)
+    end
+
+    it 'exits 2 when predicate code raises an error' do
+      _out, err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '-i', "->(model) { raise 'Boom!' }"
+      )
+      expect(status).to eq(2)
+      expect(err).to include('Predicate error: Boom!')
+    end
+
+    it 'exits 2 when predicate code has syntax error' do
+      _out, err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '-i', '-> { invalid syntax'
+      )
+      expect(status).to eq(2)
+      expect(err).to include('Syntax error in predicate code')
+    end
+
+    it 'exits 2 when predicate code is not callable' do
+      _out, err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '-i', '42'
+      )
+      expect(status).to eq(2)
+      expect(err).to include('Predicate must be callable')
+    end
+
+    it 'provides model to predicate that can query coverage' do
+      code = <<~RUBY.strip
+        ->(model) { model.summary_for('lib/foo.rb')['summary']['percentage'] > 50 }
+      RUBY
+      _out, _err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '-i', code
+      )
+      expect(status).to eq(0)
+    end
+  end
+
+  describe 'error handling' do
+    it 'raises error when no file or -i flag provided' do
+      _out, err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate'
+      )
+      expect(status).to eq(1)
+      expect(err).to include('validate <file> | -i <code>')
+    end
+
+    it 'raises error when -i flag provided without code' do
+      _out, err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '-i'
+      )
+      expect(status).to eq(1)
+      expect(err).to include('validate -i <code>')
+    end
+
+    it 'raises error when unknown option is provided' do
+      _out, err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '--unknown-option'
+      )
+      expect(status).to eq(1)
+      expect(err).to include('Unknown option for validate: --unknown-option')
+    end
+  end
+end

data/spec/commands/version_command_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../shared_examples/formatted_command_examples'
+
+RSpec.describe SimpleCovMcp::Commands::VersionCommand do
+  let(:cli_context) { SimpleCovMcp::CoverageCLI.new }
+  let(:command) { described_class.new(cli_context) }
+
+  before do
+    cli_context.config.format = :table
+  end
+
+  describe '#execute' do
+    context 'with table format' do
+      it 'prints version, gem root, and documentation info in text mode' do
+        output = capture_command_output(command, [])
+
+        expect(output).to include('│', SimpleCovMcp::VERSION, 'Gem Root', 'Documentation',
+          'README.md')
+      end
+
+      it 'includes a valid gem root path that exists' do
+        output = capture_command_output(command, [])
+
+        # Extract gem root from table output
+        gem_root_line = output.lines.find { |line| line.include?('Gem Root') }
+        expect(gem_root_line).not_to be_nil
+
+        parts = gem_root_line.split('│')
+        gem_root = parts[-2].strip
+        expect(File.directory?(gem_root)).to be true
+      end
+    end
+
+    it_behaves_like 'a command with formatted output', [], ['version', 'gem_root']
+  end
+end

data/spec/constants_spec.rb

@@ -18,14 +18,14 @@ RSpec.describe SimpleCovMcp::Constants do
       expected_options = %w[
         -r --resultset
         -R --root
+        -f --format
         -o --sort-order
         -s --source
-        -c --source-context
-        -S --stale
+        -c --context-lines
+        -S --staleness
         -g --tracked-globs
         -l --log-file
         --error-mode
-        --success-predicate
       ]
 
       expect(options).to eq(expected_options)

data/spec/coverage_reporter_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::CoverageReporter do
+  let(:model) { instance_double(SimpleCovMcp::CoverageModel) }
+  # Data is pre-sorted by percentage ascending (as model.all_files returns)
+  let(:all_files_data) do
+    [
+      { 'file' => '/project/lib/zero.rb',   'percentage' =>  0.0, 'covered' =>  0, 'total' => 10 },
+      { 'file' => '/project/lib/low.rb',    'percentage' => 25.0, 'covered' =>  5, 'total' => 20 },
+      { 'file' => '/project/lib/medium.rb', 'percentage' => 60.0, 'covered' => 12, 'total' => 20 },
+      { 'file' => '/project/lib/high.rb',   'percentage' => 95.0, 'covered' => 19, 'total' => 20 }
+    ]
+  end
+
+  before do
+    allow(model).to receive(:all_files).with(sort_order: :ascending).and_return(all_files_data)
+    allow(model).to receive(:relativize) do |files|
+      files.map { |f| f.merge('file' => f['file'].sub('/project/', '')) }
+    end
+  end
+
+  describe '.report' do
+    it 'returns formatted low coverage files string' do
+      result = described_class.report(threshold: 80, count: 5, model: model)
+
+      expect(result).to be_a(String)
+      expect(result).to include('Lowest coverage files (< 80%):')
+      expect(result).to include('lib/zero.rb')
+    end
+
+    it 'includes files below threshold sorted by coverage ascending' do
+      result = described_class.report(threshold: 80, count: 5, model: model)
+
+      expect(result).to include('lib/zero.rb', 'lib/low.rb', 'lib/medium.rb')
+      expect(result).not_to include('lib/high.rb')
+    end
+
+    it 'respects count parameter' do
+      result = described_class.report(threshold: 80, count: 2, model: model)
+
+      expect(result).to include('lib/zero.rb')
+      expect(result).to include('lib/low.rb')
+      expect(result).not_to include('lib/medium.rb')
+    end
+
+    it 'returns nil when no files below threshold' do
+      result = described_class.report(threshold: 0, count: 5, model: model)
+
+      expect(result).to be_nil
+    end
+
+    it 'uses threshold in header' do
+      result = described_class.report(threshold: 90, count: 5, model: model)
+
+      expect(result).to include('< 90%')
+    end
+
+    it 'uses default threshold of 80' do
+      result = described_class.report(count: 5, model: model)
+
+      expect(result).to include('< 80%')
+      expect(result).not_to include('lib/high.rb')
+    end
+
+    it 'uses default count of 5' do
+      result = described_class.report(threshold: 100, model: model)
+
+      # All 4 files are below 100%
+      expect(result).to include('lib/zero.rb')
+      expect(result).to include('lib/high.rb')
+    end
+
+    it 'relativizes file paths' do
+      result = described_class.report(threshold: 80, count: 5, model: model)
+
+      expect(result).to include('lib/zero.rb')
+      expect(result).not_to include('/project/')
+    end
+
+    it 'aligns percentages correctly' do
+      result = described_class.report(threshold: 100, count: 5, model: model)
+      lines = result.split("\n")
+
+      # lines[0] is empty (leading newline), lines[1] is header, lines[2..] are data
+      expect(lines[2]).to match(/^\s+0\.0%/)
+      expect(lines[3]).to match(/^\s+25\.0%/)
+    end
+  end
+
+  describe 'module_function behavior' do
+    it 'report is available as a module method' do
+      expect(described_class).to respond_to(:report)
+    end
+
+    it 'report is available as a private instance method when included' do
+      klass = Class.new { include SimpleCovMcp::CoverageReporter }
+      expect(klass.private_instance_methods).to include(:report)
+    end
+  end
+end

data/spec/coverage_table_tool_spec.rb

@@ -11,10 +11,10 @@ RSpec.describe SimpleCovMcp::Tools::CoverageTableTool do
     setup_mcp_response_stub
   end
 
-  def run_tool(stale: 'off')
+  def run_tool(staleness: :off)
     # Let real CoverageModel work to test actual format_table behavior
-    described_class.call(root: root, stale: stale,
-      server_context: server_context).payload.first[:text]
+    described_class.call(root: root, staleness: staleness,
+      server_context: server_context).payload.first['text']
   end
 
   it 'returns a formatted table as a string' do
@@ -30,12 +30,15 @@ RSpec.describe SimpleCovMcp::Tools::CoverageTableTool do
   end
 
   it 'configures CLI to enforce stale checking when requested' do
-    model = instance_double(SimpleCovMcp::CoverageModel)
-    allow(model).to receive(:all_files).and_return([
-      { 'file' => "#{root}/lib/foo.rb", 'percentage' => 100.0, 'covered' => 10, 'total' => 10, 'stale' => false }
-    ])
-    allow(model).to receive(:relativize) { |payload| payload }
-    expect(SimpleCovMcp::CoverageModel).to receive(:new).with(
+    model = instance_double(SimpleCovMcp::CoverageModel,
+      all_files: [
+        { 'file' => "#{root}/lib/foo.rb", 'percentage' => 100.0, 'covered' => 10, 'total' => 10,
+          'stale' => false }
+      ],
+      relativize: ->(payload) { payload },
+      format_table: 'Mock table output'
+    )
+    allow(SimpleCovMcp::CoverageModel).to receive(:new).with(
       root: root,
       resultset: nil,
       staleness: :error,
@@ -43,6 +46,14 @@ RSpec.describe SimpleCovMcp::Tools::CoverageTableTool do
     ).and_return(model)
     allow(model).to receive(:format_table).and_return('Mock table output')
 
-    described_class.call(root: root, stale: 'error', server_context: server_context)
+    described_class.call(root: root, staleness: :error, server_context: server_context)
+
+    expect(SimpleCovMcp::CoverageModel).to have_received(:new).with(
+      root: root,
+      resultset: nil,
+      staleness: :error,
+      tracked_globs: nil
+    )
+    expect(model).to have_received(:format_table)
   end
 end

data/spec/coverage_totals_tool_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'simplecov_mcp/tools/coverage_totals_tool'
+
+RSpec.describe SimpleCovMcp::Tools::CoverageTotalsTool do
+  subject(:tool_response) { described_class.call(root: root, server_context: server_context) }
+
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:server_context) { instance_double('ServerContext').as_null_object }
+
+  before do
+    setup_mcp_response_stub
+    model = instance_double(SimpleCovMcp::CoverageModel)
+    allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
+
+    payload = {
+      'lines' => { 'total' => 42, 'covered' => 40, 'uncovered' => 2 },
+      'percentage' => 95.24,
+      'files' => { 'total' => 4, 'ok' => 4, 'stale' => 0 }
+    }
+
+    presenter = instance_double(SimpleCovMcp::Presenters::ProjectTotalsPresenter)
+    allow(SimpleCovMcp::Presenters::ProjectTotalsPresenter).to receive(:new).and_return(presenter)
+    allow(presenter).to receive(:relativized_payload).and_return(payload)
+  end
+
+  it_behaves_like 'an MCP tool that returns text JSON'
+
+  it 'returns aggregated totals' do
+    data, = expect_mcp_text_json(tool_response, expected_keys: ['lines', 'percentage', 'files'])
+
+    expect(data['lines']).to include('total' => 42, 'covered' => 40, 'uncovered' => 2)
+    expect(data['files']).to include('total' => 4, 'stale' => 0)
+    expect(data['percentage']).to eq(95.24)
+  end
+end

data/spec/error_handler_spec.rb

@@ -3,16 +3,17 @@
 require 'spec_helper'
 
 RSpec.describe SimpleCovMcp::ErrorHandler do
+  subject(:handler) { described_class.new(error_mode: :log, logger: logger) }
+
   let(:logger) do
     Class.new do
       attr_reader :messages
 
-      def initialize; @messages = []; end
-      def error(msg); @messages << msg; end
+      def initialize = @messages = []
+      def error(msg) = @messages << msg
     end.new
   end
 
-  subject(:handler) { described_class.new(error_mode: :on, logger: logger) }
 
   it 'maps filesystem errors to friendly custom errors' do
     e = handler.convert_standard_error(Errno::EISDIR.new('Is a directory @ rb_sysopen - a_dir'))
@@ -73,9 +74,124 @@ RSpec.describe SimpleCovMcp::ErrorHandler do
     begin
       handler.handle_error(Errno::ENOENT.new('No such file or directory @ rb_sysopen - x'),
         context: 'test', reraise: false)
-    rescue StandardError
+    rescue
       # reraise disabled
     end
     expect(logger.messages.join).to include('Error in test')
   end
+
+  it 'converts TypeError to CoverageDataError for invalid data structures' do
+    error = TypeError.new('wrong argument type')
+    result = handler.convert_standard_error(error)
+
+    expect(result).to be_a(SimpleCovMcp::CoverageDataError)
+    expect(result.user_friendly_message).to include('Invalid coverage data structure')
+  end
+
+  it 'returns generic Error for unrecognized SystemCallError' do
+    error = Errno::EEXIST.new('File exists')
+    result = handler.convert_standard_error(error)
+
+    expect(result).to be_a(SimpleCovMcp::Error)
+    expect(result.user_friendly_message).to include('An unexpected error occurred')
+  end
+
+  it 'handles NoMethodError with non-standard message format' do
+    error = NoMethodError.new('some weird error message without the expected pattern')
+    result = handler.convert_standard_error(error)
+
+    expect(result).to be_a(SimpleCovMcp::CoverageDataError)
+    expect(result.user_friendly_message).to include('some weird error message')
+  end
+
+  describe 'else branch for non-StandardError exceptions' do
+    # This tests the else clause in convert_standard_error for exceptions
+    # that don't inherit from StandardError
+    it 'returns generic Error for Exception subclasses not inheriting from StandardError' do
+      # Create a custom exception that inherits from Exception, not StandardError
+      custom_exception_class = Class.new(StandardError) do
+        def message
+          'Custom non-standard exception'
+        end
+      end
+
+      error = custom_exception_class.new
+      result = handler.convert_standard_error(error)
+
+      expect(result).to be_a(SimpleCovMcp::Error)
+      expect(result.user_friendly_message).to include('An unexpected error occurred')
+      expect(result.user_friendly_message).to include('Custom non-standard exception')
+    end
+
+    it 'returns generic Error for ScriptError subclasses' do
+      # ScriptError inherits from Exception, not StandardError
+      error = NotImplementedError.new('This feature is not implemented')
+      result = handler.convert_standard_error(error)
+
+      expect(result).to be_a(SimpleCovMcp::Error)
+      expect(result.user_friendly_message).to include('An unexpected error occurred')
+    end
+  end
+
+  describe 'extract_method_info fallback' do
+    # This tests the fallback path in extract_method_info when NoMethodError
+    # message doesn't match the expected pattern
+    it 'returns original message when pattern does not match' do
+      # Test various NoMethodError formats that won't match the regex
+      test_messages = [
+        'method not found',
+        'private method called',
+        'undefined local variable or method',
+        ''
+      ]
+
+      test_messages.each do |msg|
+        error = NoMethodError.new(msg)
+        result = handler.convert_standard_error(error)
+
+        expect(result).to be_a(SimpleCovMcp::CoverageDataError)
+        # The original message should be preserved
+        expect(result.message).to include(msg) unless msg.empty?
+      end
+    end
+  end
+
+  # ErrorHandler#convert_runtime_error handles RuntimeErrors differently based on context:
+  # - :coverage_loading assumes errors relate to coverage data and maps them to
+  #   CoverageDataError or ResultsetNotFoundError
+  # - :general (or any other context) maps unrecognized errors to generic Error
+  # This tests the final else branch in convert_runtime_error.
+  describe 'convert_runtime_error with general context' do
+    it 'converts RuntimeError with unrecognized message to generic Error' do
+      error = RuntimeError.new('Some completely unexpected runtime error')
+
+      result = handler.convert_standard_error(error, context: :general)
+
+      expect(result).to be_a(SimpleCovMcp::Error)
+      expect(result.user_friendly_message)
+        .to include('An unexpected error occurred', 'unexpected runtime error')
+    end
+  end
+
+  describe '#handle_error with reraise' do
+    it 're-raises SimpleCovMcp::Error when reraise is true' do
+      error = SimpleCovMcp::FileNotFoundError.new('Test file not found')
+
+      expect { handler.handle_error(error, context: 'test', reraise: true) }
+        .to raise_error(SimpleCovMcp::FileNotFoundError, 'Test file not found')
+
+      # Verify it was logged
+      expect(logger.messages.join).to include('Error in test')
+    end
+
+    it 'converts and re-raises StandardError when reraise is true' do
+      error = Errno::ENOENT.new('No such file or directory @ rb_sysopen - missing.rb')
+
+      expect { handler.handle_error(error, context: 'test', reraise: true) }
+        .to raise_error(SimpleCovMcp::FileNotFoundError)
+
+      # Verify it was logged
+      expect(logger.messages.join).to include('Error in test')
+    end
+  end
 end