simplecov-mcp 0.3.0 → 1.0.0

data/spec/cli_success_predicate_spec.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tempfile'
+
+RSpec.describe SimpleCovMcp::CoverageCLI, 'success predicate' 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 '--success-predicate' 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(
+          '--success-predicate', path,
+          '--root', root,
+          '--resultset', 'coverage'
+        )
+        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(
+          '--success-predicate', path,
+          '--root', root,
+          '--resultset', 'coverage'
+        )
+        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(
+          '--success-predicate', path,
+          '--root', root,
+          '--resultset', 'coverage'
+        )
+        expect(status).to eq(2)
+        expect(err).to include('Success predicate error: Boom!')
+      end
+    end
+
+    it 'shows backtrace when predicate errors with --error-mode trace' do
+      with_temp_predicate("->(model) { raise 'Boom!' }\n") do |path|
+        _out, err, status = run_cli_with_status(
+          '--success-predicate', path,
+          '--root', root,
+          '--resultset', 'coverage',
+          '--error-mode', 'trace'
+        )
+        expect(status).to eq(2)
+        expect(err).to include('Success 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(
+        '--success-predicate', '/nonexistent/predicate.rb',
+        '--root', root,
+        '--resultset', 'coverage'
+      )
+      expect(status).to eq(2)
+      expect(err).to include('Success 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(
+          '--success-predicate', path,
+          '--root', root,
+          '--resultset', 'coverage'
+        )
+        expect(status).to eq(2)
+        expect(err).to include('Syntax error in success 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(
+          '--success-predicate', path,
+          '--root', root,
+          '--resultset', 'coverage'
+        )
+        expect(status).to eq(2)
+        expect(err).to include('Success 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']['pct'] > 50  # Should be true for foo.rb
+        end
+      RUBY
+        _out, _err, status = run_cli_with_status(
+          '--success-predicate', path,
+          '--root', root,
+          '--resultset', 'coverage'
+        )
+        expect(status).to eq(0)
+      end
+    end
+  end
+
+  describe 'run_subcommand error handling' do
+    it 'handles generic errors in subcommands' do
+      # Force a generic error in the command execution
+      fake_command_class = Class.new do
+        def initialize(_cli); end
+
+        def execute(_args)
+          raise StandardError, 'Generic error in command'
+        end
+      end
+
+      allow(SimpleCovMcp::Commands::CommandFactory).to receive(:create)
+        .and_return(fake_command_class.new(nil))
+
+      _out, err, status = run_cli_with_status('summary', 'lib/foo.rb', '--root', root,
+        '--resultset', 'coverage')
+
+      expect(status).to eq(1)
+      expect(err).to include('An unexpected error occurred')
+    end
+  end
+end

data/spec/cli_table_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 RSpec.describe SimpleCovMcp::CoverageCLI do
-  let(:root) { (FIXTURES / 'project1').to_s }
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
 
   def run_cli(*argv)
     cli = described_class.new

data/spec/cli_usage_spec.rb

@@ -3,24 +3,7 @@
 require 'spec_helper'
 
 RSpec.describe SimpleCovMcp::CoverageCLI do
-  let(:root) { (FIXTURES / 'project1').to_s }
-
-  def run_cli_with_status(*argv)
-    cli = described_class.new
-    status = nil
-    out_str = err_str = nil
-    silence_output do |out, err|
-      begin
-        cli.run(argv.flatten)
-        status = 0
-      rescue SystemExit => e
-        status = e.status
-      end
-      out_str = out.string
-      err_str = err.string
-    end
-    [out_str, err_str, status]
-  end
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
 
   it 'errors with usage when summary path is missing' do
     _out, err, status = run_cli_with_status('summary', '--root', root, '--resultset', 'coverage')
@@ -28,19 +11,19 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
     expect(err).to include('Usage: simplecov-mcp summary <path>')
   end
 
-  it 'treats unknown subcommand as no subcommand and prints default table' do
+  it 'errors with meaningful message for unknown subcommand' do
     out, err, status = run_cli_with_status('bogus', '--root', root, '--resultset', 'coverage')
-    expect(status).to eq(0)
-    expect(err).to eq("")
-    expect(out).to include('File')
-    expect(out).to include('lib/foo.rb')
+    expect(status).to eq(1)
+    expect(err).to include("Unknown subcommand: 'bogus'")
+    expect(err).to include('Valid subcommands:')
   end
 
   it 'list honors stale=error and tracked_globs by exiting 1 when project is stale' do
     tmp = File.join(root, 'lib', 'brand_new_file_for_cli_usage_spec.rb')
     begin
       File.write(tmp, "# new file\n")
-      _out, err, status = run_cli_with_status('list', '--root', root, '--resultset', 'coverage', '--stale', 'error', '--tracked-globs', 'lib/**/*.rb')
+      _out, err, status = run_cli_with_status('list', '--root', root, '--resultset', 'coverage',
+        '--stale', 'error', '--tracked-globs', 'lib/**/*.rb')
       expect(status).to eq(1)
       expect(err).to include('Coverage data stale (project)')
     ensure
@@ -49,9 +32,10 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
   end
 
   it 'list with stale=off prints table and exits 0' do
-    out, err, status = run_cli_with_status('list', '--root', root, '--resultset', 'coverage', '--stale', 'off')
+    out, err, status = run_cli_with_status('list', '--root', root, '--resultset', 'coverage',
+      '--stale', 'off')
     expect(status).to eq(0)
-    expect(err).to eq("")
+    expect(err).to eq('')
     expect(out).to include('File')
     expect(out).to include('lib/foo.rb')
   end

data/spec/commands/base_command_spec.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::Commands::BaseCommand do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:cli_context) { SimpleCovMcp::CoverageCLI.new }
+
+  # Create a test command class that exposes protected methods for testing
+  let(:test_command_class) do
+    Class.new(SimpleCovMcp::Commands::BaseCommand) do
+      def execute(args)
+        # Not needed for these tests
+      end
+
+      # Expose protected methods for testing
+      def public_handle_with_path(args, name, &block)
+        handle_with_path(args, name, &block)
+      end
+
+      def public_fetch_raw(model, path)
+        fetch_raw(model, path)
+      end
+    end
+  end
+
+  let(:test_command) { test_command_class.new(cli_context) }
+
+  describe '#handle_with_path' do
+    context 'when Errno::ENOENT is raised' do
+      it 'converts to FileNotFoundError with correct message' do
+        args = ['lib/missing.rb']
+
+        # Stub the block to raise Errno::ENOENT
+        expect do
+          test_command.public_handle_with_path(args, 'test') do |path|
+            raise Errno::ENOENT.new('No such file or directory')
+          end
+        end.to raise_error(SimpleCovMcp::FileNotFoundError, 'File not found: lib/missing.rb')
+      end
+
+      it 'includes the path from the args in the error message' do
+        args = ['some/other/path.rb']
+
+        expect do
+          test_command.public_handle_with_path(args, 'test') do |path|
+            raise Errno::ENOENT.new('No such file or directory')
+          end
+        end.to raise_error(SimpleCovMcp::FileNotFoundError, /some\/other\/path\.rb/)
+      end
+    end
+
+    context 'when Errno::EACCES is raised' do
+      it 'converts to FilePermissionError with correct message' do
+        args = ['lib/secret.rb']
+
+        # Stub the block to raise Errno::EACCES
+        expect do
+          test_command.public_handle_with_path(args, 'test') do |path|
+            raise Errno::EACCES.new('Permission denied')
+          end
+        end.to raise_error(SimpleCovMcp::FilePermissionError, 'Permission denied: lib/secret.rb')
+      end
+
+      it 'includes the path from the args in the error message' do
+        args = ['/root/protected.rb']
+
+        expect do
+          test_command.public_handle_with_path(args, 'test') do |path|
+            raise Errno::EACCES.new('Permission denied')
+          end
+        end.to raise_error(SimpleCovMcp::FilePermissionError, /\/root\/protected\.rb/)
+      end
+    end
+
+    context 'when no path is provided' do
+      it 'raises UsageError' do
+        args = []
+
+        expect do
+          test_command.public_handle_with_path(args, 'summary') do |path|
+            # Should not reach here
+          end
+        end.to raise_error(SimpleCovMcp::UsageError, /summary <path>/)
+      end
+    end
+
+    context 'when successful' do
+      it 'yields the path to the block' do
+        args = ['lib/foo.rb']
+        yielded_path = nil
+
+        test_command.public_handle_with_path(args, 'test') do |path|
+          yielded_path = path
+        end
+
+        expect(yielded_path).to eq('lib/foo.rb')
+      end
+
+      it 'shifts the path from args' do
+        args = ['lib/foo.rb', 'extra', 'args']
+
+        test_command.public_handle_with_path(args, 'test') do |path|
+          # Block execution
+        end
+
+        expect(args).to eq(['extra', 'args'])
+      end
+    end
+  end
+
+  describe '#fetch_raw' do
+    let(:model) { SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage') }
+
+    context 'when model.raw_for raises an exception' do
+      it 'returns nil instead of propagating the error' do
+        # Stub model.raw_for to raise an exception
+        allow(model).to receive(:raw_for).and_raise(StandardError, 'Something went wrong')
+
+        result = test_command.public_fetch_raw(model, 'lib/nonexistent.rb')
+
+        expect(result).to be_nil
+      end
+
+      it 'handles RuntimeError' do
+        allow(model).to receive(:raw_for).and_raise(RuntimeError, 'Runtime error')
+
+        result = test_command.public_fetch_raw(model, 'lib/foo.rb')
+
+        expect(result).to be_nil
+      end
+
+      it 'handles ArgumentError' do
+        allow(model).to receive(:raw_for).and_raise(ArgumentError, 'Invalid argument')
+
+        result = test_command.public_fetch_raw(model, 'lib/foo.rb')
+
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when successful' do
+      it 'returns the raw coverage data' do
+        result = test_command.public_fetch_raw(model, 'lib/foo.rb')
+
+        expect(result).to be_a(Hash)
+        expect(result).to have_key('lines')
+        expect(result['lines']).to be_an(Array)
+      end
+
+      it 'caches the result for subsequent calls' do
+        # First call should hit the model
+        expect(model).to receive(:raw_for).with('lib/foo.rb').once.and_call_original
+
+        result1 = test_command.public_fetch_raw(model, 'lib/foo.rb')
+        result2 = test_command.public_fetch_raw(model, 'lib/foo.rb')
+
+        expect(result1).to eq(result2)
+      end
+
+      it 'caches different paths separately' do
+        result1 = test_command.public_fetch_raw(model, 'lib/foo.rb')
+        result2 = test_command.public_fetch_raw(model, 'lib/bar.rb')
+
+        expect(result1).not_to eq(result2)
+      end
+
+      it 'does not cache nil results from exceptions' do
+        # Set up the stub to raise an error
+        call_count = 0
+        allow(model).to receive(:raw_for).with('lib/missing.rb') do
+          call_count += 1
+          raise StandardError, 'File not found'
+        end
+
+        result1 = test_command.public_fetch_raw(model, 'lib/missing.rb')
+        result2 = test_command.public_fetch_raw(model, 'lib/missing.rb')
+
+        expect(result1).to be_nil
+        expect(result2).to be_nil
+        # Note: Due to current implementation, nil results are NOT cached,
+        # so raw_for is called each time an exception occurs
+        expect(call_count).to eq(2)
+      end
+    end
+  end
+end

data/spec/commands/command_factory_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::Commands::CommandFactory do
+  let(:cli_context) { SimpleCovMcp::CoverageCLI.new }
+
+  describe '.create' do
+    context 'with valid command names' do
+      [
+        ['list', SimpleCovMcp::Commands::ListCommand],
+        ['version', SimpleCovMcp::Commands::VersionCommand],
+        ['summary', SimpleCovMcp::Commands::SummaryCommand],
+        ['raw', SimpleCovMcp::Commands::RawCommand],
+        ['uncovered', SimpleCovMcp::Commands::UncoveredCommand],
+        ['detailed', SimpleCovMcp::Commands::DetailedCommand]
+      ].each do |command_name, command_class|
+        it "creates a #{command_class.name.split('::').last} for \"#{command_name}\"" do
+          command = described_class.create(command_name, cli_context)
+          expect(command).to be_a(command_class)
+        end
+      end
+    end
+
+    context 'with unknown command name' do
+      [
+        [
+          'invalid_cmd',
+          'invalid command',
+          /list | summary <path> | raw <path> | uncovered <path> | detailed <path> | version/
+        ],
+        [nil,           'nil command',            nil],
+        ['',            'empty string command',   nil],
+        ['sumary',      'misspelled command',     nil]
+      ].each do |command_name, description, pattern|
+        it "raises UsageError for #{description}" do
+          expect do
+            described_class.create(command_name, cli_context)
+          end.to raise_error(SimpleCovMcp::UsageError, pattern)
+        end
+      end
+    end
+  end
+
+  describe '.available_commands' do
+    it 'returns an array of available command names' do
+      commands = described_class.available_commands
+      expect(commands).to be_an(Array)
+      expect(commands).to contain_exactly('list', 'version', 'summary', 'raw', 'uncovered',
+        'detailed')
+    end
+
+    it 'returns the keys from COMMAND_MAP' do
+      expect(described_class.available_commands).to eq(described_class::COMMAND_MAP.keys)
+    end
+  end
+
+  describe 'COMMAND_MAP' do
+    it 'is frozen to prevent modifications' do
+      expect(described_class::COMMAND_MAP).to be_frozen
+    end
+
+    it 'maps command names to command classes' do
+      expect(described_class::COMMAND_MAP['list']).to eq(SimpleCovMcp::Commands::ListCommand)
+      expect(described_class::COMMAND_MAP['version']).to eq(SimpleCovMcp::Commands::VersionCommand)
+      expect(described_class::COMMAND_MAP['summary']).to eq(SimpleCovMcp::Commands::SummaryCommand)
+      expect(described_class::COMMAND_MAP['raw']).to eq(SimpleCovMcp::Commands::RawCommand)
+      expect(described_class::COMMAND_MAP['uncovered']).to eq(SimpleCovMcp::Commands::UncoveredCommand)
+      expect(described_class::COMMAND_MAP['detailed']).to eq(SimpleCovMcp::Commands::DetailedCommand)
+    end
+  end
+end

data/spec/commands/detailed_command_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::Commands::DetailedCommand do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:cli_context) { SimpleCovMcp::CoverageCLI.new }
+  let(:command) { described_class.new(cli_context) }
+
+  before do
+    cli_context.config.root = root
+    cli_context.config.resultset = 'coverage'
+    cli_context.config.json = false
+    cli_context.config.source_mode = nil
+  end
+
+  describe '#execute' do
+    it 'prints the detailed coverage table' do
+      output = nil
+
+      silence_output do |stdout, _stderr|
+        command.execute(['lib/foo.rb'])
+        output = stdout.string
+      end
+
+      expect(output).to include('File: lib/foo.rb')
+      expect(output).to include('Line')
+      expect(output).to include('Covered')
+    end
+
+    it 'emits JSON when requested, including stale metadata' do
+      cli_context.config.json = true
+      stub_staleness_check('L')
+
+      json_output = nil
+      silence_output do |stdout, _stderr|
+        command.execute(['lib/foo.rb'])
+        json_output = stdout.string
+      end
+
+      payload = JSON.parse(json_output)
+      expect(payload['file']).to eq('lib/foo.rb')
+      expect(payload['lines']).to be_an(Array)
+      expect(payload['summary']).to include('covered' => 2, 'total' => 3, 'pct' => 66.67)
+      expect(payload['stale']).to eq('L')
+    end
+  end
+end

data/spec/commands/raw_command_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::Commands::RawCommand do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:cli_context) { SimpleCovMcp::CoverageCLI.new }
+  let(:command) { described_class.new(cli_context) }
+
+  before do
+    cli_context.config.root = root
+    cli_context.config.resultset = 'coverage'
+    cli_context.config.json = false
+  end
+
+  describe '#execute' do
+    it 'prints the raw coverage lines for the requested file' do
+      output = nil
+
+      silence_output do |stdout, _stderr|
+        command.execute(['lib/foo.rb'])
+        output = stdout.string
+      end
+
+      expect(output).to include('File: lib/foo.rb')
+      # Example match: "[1, 0, nil, 2]"
+      expect(output).to match(/\[1,\s0,\snil,\s2\]/)
+    end
+
+    it 'emits JSON when requested, including stale metadata' do
+      cli_context.config.json = true
+      stub_staleness_check('L')
+
+      json_output = nil
+      silence_output do |stdout, _stderr|
+        command.execute(['lib/foo.rb'])
+        json_output = stdout.string
+      end
+
+      payload = JSON.parse(json_output)
+      expect(payload['file']).to eq('lib/foo.rb')
+      expect(payload['lines']).to eq([1, 0, nil, 2])
+      expect(payload['stale']).to eq('L')
+    end
+  end
+end

data/spec/commands/summary_command_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::Commands::SummaryCommand do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:cli_context) { SimpleCovMcp::CoverageCLI.new }
+  let(:command) { described_class.new(cli_context) }
+
+  before do
+    cli_context.config.root = root
+    cli_context.config.resultset = 'coverage'
+    cli_context.config.json = false
+    cli_context.config.source_mode = nil
+  end
+
+  describe '#execute' do
+    it 'prints a coverage summary line with a relative path' do
+      output = nil
+
+      silence_output do |stdout, _stderr|
+        command.execute(['lib/foo.rb'])
+        output = stdout.string
+      end
+
+      # Example match: "   66.67%       2/3       lib/foo.rb"
+      expect(output).to match(/66\.67%.*2\/3.*lib\/foo\.rb/)
+    end
+
+    it 'emits JSON when requested, including stale metadata' do
+      cli_context.config.json = true
+      stub_staleness_check('L')
+
+      json_output = nil
+      silence_output do |stdout, _stderr|
+        command.execute(['lib/foo.rb'])
+        json_output = stdout.string
+      end
+
+      payload = JSON.parse(json_output)
+      expect(payload['file']).to eq('lib/foo.rb')
+      expect(payload['summary']).to include('covered' => 2, 'total' => 3, 'pct' => 66.67)
+      expect(payload).to have_key('stale')
+      expect(payload['stale']).to eq('L')
+    end
+  end
+end

data/spec/commands/uncovered_command_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::Commands::UncoveredCommand do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:cli_context) { SimpleCovMcp::CoverageCLI.new }
+  let(:command) { described_class.new(cli_context) }
+
+  before do
+    cli_context.config.root = root
+    cli_context.config.resultset = 'coverage'
+    cli_context.config.json = false
+    cli_context.config.source_mode = nil
+  end
+
+  describe '#execute' do
+    it 'prints uncovered line numbers with the summary' do
+      output = nil
+
+      silence_output do |stdout, _stderr|
+        command.execute(['lib/foo.rb'])
+        output = stdout.string
+      end
+
+      expect(output).to include('File:            lib/foo.rb')
+      expect(output).to include('Uncovered lines: 2')
+      # Example match: "Summary:         66.67%       2/3"
+      expect(output).to match(/Summary:\s+66\.67%.*2\/3/)
+    end
+
+    it 'emits JSON when requested, including stale metadata' do
+      cli_context.config.json = true
+      stub_staleness_check('L')
+
+      json_output = nil
+      silence_output do |stdout, _stderr|
+        command.execute(['lib/foo.rb'])
+        json_output = stdout.string
+      end
+
+      payload = JSON.parse(json_output)
+      expect(payload['file']).to eq('lib/foo.rb')
+      expect(payload['uncovered']).to eq([2])
+      expect(payload['summary']).to include('covered' => 2, 'total' => 3, 'pct' => 66.67)
+      expect(payload['stale']).to eq('L')
+    end
+  end
+end