simplecov-mcp 1.0.0 → 2.0.0

data/spec/staleness_checker_spec.rb

@@ -5,6 +5,7 @@ require 'fileutils'
 
 RSpec.describe SimpleCovMcp::StalenessChecker do
   let(:tmpdir) { Dir.mktmpdir('scmcp-stale') }
+
   after { FileUtils.remove_entry(tmpdir) if tmpdir && File.directory?(tmpdir) }
 
   def write_file(path, lines)
@@ -57,8 +58,8 @@ RSpec.describe SimpleCovMcp::StalenessChecker do
     end
   end
 
-  context 'compute_file_staleness_details' do
-    include_examples 'a staleness check',
+  context 'when computing file staleness details' do
+    it_behaves_like 'a staleness check',
       description: 'detects newer file vs coverage timestamp',
       file_lines: ['a', 'b'],
       coverage_lines: [1, 1],
@@ -75,7 +76,7 @@ RSpec.describe SimpleCovMcp::StalenessChecker do
       expected_stale_char: 'T',
       expected_error: SimpleCovMcp::CoverageDataStaleError
 
-    include_examples 'a staleness check',
+    it_behaves_like 'a staleness check',
       description: 'detects length mismatch between source and coverage',
       file_lines: ['a', 'b', 'c', 'd'],
       coverage_lines: [1, 1],
@@ -92,7 +93,7 @@ RSpec.describe SimpleCovMcp::StalenessChecker do
       expected_stale_char: 'L',
       expected_error: SimpleCovMcp::CoverageDataStaleError
 
-    include_examples 'a staleness check',
+    it_behaves_like 'a staleness check',
       description: 'treats missing file as stale',
       file_lines: nil,
       coverage_lines: [1, 1, 1],
@@ -107,7 +108,7 @@ RSpec.describe SimpleCovMcp::StalenessChecker do
       expected_stale_char: 'M',
       expected_error: SimpleCovMcp::CoverageDataStaleError
 
-    include_examples 'a staleness check',
+    it_behaves_like 'a staleness check',
       description: 'is not stale when timestamps and lengths match',
       file_lines: ['a', 'b', 'c'],
       coverage_lines: [1, 0, nil],
@@ -123,7 +124,7 @@ RSpec.describe SimpleCovMcp::StalenessChecker do
       expected_error: nil
   end
 
-  context 'missing_trailing_newline? edge cases' do
+  context 'when handling missing_trailing_newline? edge cases' do
     let(:checker) do
       described_class.new(root: tmpdir, resultset: nil, mode: 'off', timestamp: Time.now)
     end
@@ -192,7 +193,7 @@ RSpec.describe SimpleCovMcp::StalenessChecker do
     end
   end
 
-  context 'line count adjustment with missing trailing newline' do
+  context 'when adjusting line count with missing trailing newline' do
     let(:checker) do
       described_class.new(root: tmpdir, resultset: nil, mode: 'off', timestamp: Time.now)
     end
@@ -246,7 +247,7 @@ RSpec.describe SimpleCovMcp::StalenessChecker do
     end
   end
 
-  context 'safe_count_lines edge cases' do
+  context 'when handling safe_count_lines edge cases' do
     let(:checker) do
       described_class.new(root: tmpdir, resultset: nil, mode: 'off', timestamp: Time.now)
     end
@@ -287,7 +288,7 @@ RSpec.describe SimpleCovMcp::StalenessChecker do
     end
   end
 
-  context 'rel method with path prefix mismatches' do
+  context 'when rel has path prefix mismatches' do
     let(:checker) do
       described_class.new(root: tmpdir, resultset: nil, mode: 'off', timestamp: Time.now)
     end

data/spec/staleness_more_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-RSpec.describe 'Additional staleness cases' do
+RSpec.describe SimpleCovMcp do
   let(:root) { (FIXTURES_DIR / 'project1').to_s }
 
   describe SimpleCovMcp::CoverageModel do
@@ -11,7 +11,7 @@ RSpec.describe 'Additional staleness cases' do
       mock_resultset_with_timestamp(root, Time.now.to_i, coverage: {
         File.join(root, 'lib', 'bar.rb') => { 'lines' => [1, 1] } # 2 entries vs 3 lines in source
       })
-      model = SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage', staleness: 'error')
+      model = described_class.new(root: root, resultset: 'coverage', staleness: :error)
       # bar.rb has 2 coverage entries but 3 source lines in fixtures
       expect do
         model.summary_for('lib/bar.rb')
@@ -21,7 +21,7 @@ RSpec.describe 'Additional staleness cases' do
 
   describe SimpleCovMcp::StalenessChecker do
     it 'flags deleted files present only in coverage' do
-      checker = described_class.new(root: root, resultset: 'coverage', mode: 'error',
+      checker = described_class.new(root: root, resultset: 'coverage', mode: :error,
         timestamp: Time.now.to_i)
       coverage_map = {
         File.join(root, 'lib', 'does_not_exist_anymore.rb') => { 'lines' => [1] }
@@ -32,7 +32,7 @@ RSpec.describe 'Additional staleness cases' do
     end
 
     it 'does not raise for empty tracked_globs when nothing else is stale' do
-      checker = described_class.new(root: root, resultset: 'coverage', mode: 'error',
+      checker = described_class.new(root: root, resultset: 'coverage', mode: :error,
         tracked_globs: [], timestamp: Time.now.to_i)
       expect do
         checker.check_project!({})

data/spec/support/cli_helpers.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# CLI test helpers
+module CLITestHelpers
+  # Run CLI with the given arguments and return [stdout, stderr, exit_status]
+  def run_cli_with_status(*argv)
+    cli = SimpleCovMcp::CoverageCLI.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
+end

data/spec/support/control_flow_helpers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Helpers for managing control flow in RSpec tests.
+module ControlFlowHelpers
+  # Execute a block that's expected to call exit() without terminating the test.
+  # Useful for testing CLI commands that normally exit.
+  # Returns the exit status code if exit was called, otherwise returns the block's value.
+  #
+  # Examples:
+  #   status = swallow_system_exit { cli.run(['--help']) }
+  #   expect(status).to eq(0)  # --help calls exit(0)
+  #
+  #   result = swallow_system_exit { some_computation }
+  #   expect(result).to eq(expected_value)  # no exit, returns block value
+  def swallow_system_exit
+    yield
+  rescue SystemExit => e
+    e.status
+  end
+end

data/spec/support/fake_mcp.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module FakeMCP
+  # Fake server captures the last created instance so we can assert on the
+  # name/version/tools passed in by SimpleCovMcp::MCPServer.
+  class Server
+    class << self
+      attr_accessor :last_instance
+    end
+    attr_reader :params
+
+    def initialize(name:, version:, tools:)
+      @params = { name: name, version: version, tools: tools }
+      self.class.last_instance = self
+    end
+  end
+
+  # Fake stdio transport records whether `open` was called and the server
+  # it was initialized with.
+  class StdioTransport
+    class << self
+      attr_accessor :last_instance
+    end
+    attr_reader :server, :opened
+
+    def initialize(server)
+      @server = server
+      @opened = false
+      self.class.last_instance = self
+    end
+
+    def open
+      @opened = true
+    end
+
+    def opened?
+      @opened
+    end
+  end
+end

data/spec/support/io_helpers.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Shared test helpers for I/O operations (e.g., capturing stdout/stderr).
+module TestIOHelpers
+  # Suppress stdout/stderr within the given block, yielding the StringIOs
+  def silence_output
+    original_stdout = $stdout
+    original_stderr = $stderr
+    $stdout = StringIO.new
+    $stderr = StringIO.new
+    yield $stdout, $stderr
+  ensure
+    $stdout = original_stdout
+    $stderr = original_stderr
+  end
+
+  # Capture the output of a command execution
+  # @param command [SimpleCovMcp::Commands::BaseCommand] The command instance to execute
+  # @param args [Array] The arguments to pass to execute
+  # @return [String] The captured output
+  def capture_command_output(command, args)
+    output = nil
+    silence_output do |stdout, _stderr|
+      command.execute(args.dup)
+      output = stdout.string
+    end
+    output
+  end
+end

data/spec/support/mcp_helpers.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# MCP Tool shared examples and helpers
+module MCPToolTestHelpers
+  def setup_mcp_response_stub
+    # Standardized MCP::Tool::Response stub that works for all tools
+    response_class = Class.new do
+      attr_reader :payload, :meta
+
+      def initialize(payload, meta: nil)
+        @payload = payload
+        @meta = meta
+      end
+    end
+    stub_const('MCP::Tool::Response', response_class)
+  end
+
+  def expect_mcp_text_json(response, expected_keys: [])
+    item = response.payload.first
+
+    # Check for a 'text' part
+    expect(item['type']).to eq('text')
+    expect(item).to have_key('text')
+
+    # Parse and validate JSON content
+    data = JSON.parse(item['text'])
+
+    # Check for expected keys
+    expected_keys.each do |key|
+      expect(data).to have_key(key)
+    end
+
+    [data, item] # Return for additional custom assertions
+  end
+end

data/spec/support/mcp_runner.rb

@@ -15,9 +15,7 @@ module Spec
       # always returns a hash containing those streams plus the `Process::Status`
       # so callers can make assertions without duplicating the boilerplate.
 
-      module_function
-
-      def call(requests: nil, input: nil, env: {}, lib_path:, exe_path:, timeout: 5,
+      module_function def call(requests: nil, input: nil, env: {}, lib_path:, exe_path:, timeout: 5,
         close_stdin: true)
         payload = build_payload(requests, input)
 
@@ -44,15 +42,19 @@ module Spec
         raise "MCP server timed out after #{timeout} seconds"
       end
 
-      def call_json(request_hash, **kwargs)
-        call(requests: request_hash, **kwargs)
+      module_function def call_json(request_hash, input: nil, env: {}, lib_path:, exe_path:,
+        timeout: 5, close_stdin: true)
+        call(requests: request_hash, input: input, env: env, lib_path: lib_path,
+          exe_path: exe_path, timeout: timeout, close_stdin: close_stdin)
       end
 
-      def call_json_stream(request_hashes, **kwargs)
-        call(requests: Array(request_hashes), **kwargs)
+      module_function def call_json_stream(request_hashes, input: nil, env: {}, lib_path:,
+        exe_path:, timeout: 5, close_stdin: true)
+        call(requests: Array(request_hashes), input: input, env: env, lib_path: lib_path,
+          exe_path: exe_path, timeout: timeout, close_stdin: close_stdin)
       end
 
-      def build_payload(requests, input)
+      module_function def build_payload(requests, input)
         return input unless requests
 
         normalized = requests.is_a?(Array) ? requests : [requests]

data/spec/support/mocking_helpers.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Helpers for mocking and stubbing objects in RSpec tests.
+module MockingHelpers
+  # Stub staleness checking to return a specific value
+  # @param value [String, false] The staleness value to return ('L', 'T', 'M', or false)
+  def stub_staleness_check(value)
+    checker_double = instance_double(SimpleCovMcp::StalenessChecker)
+    allow(checker_double).to receive_messages(
+      stale_for_file?: value,
+      off?: false
+    )
+    allow(checker_double).to receive(:check_file!)
+    allow(SimpleCovMcp::StalenessChecker).to receive(:new).and_return(checker_double)
+  end
+
+  # Stub a presenter with specific payload data
+  # @param presenter_class [Class] The presenter class to stub (e.g., SimpleCovMcp::Presenters::CoverageRawPresenter)
+  # @param absolute_payload [Hash] The data hash to return from #absolute_payload
+  # @param relative_path [String] The path to return from #relative_path
+  def mock_presenter(presenter_class, absolute_payload:, relative_path:)
+    presenter_double = instance_double(presenter_class)
+    allow(presenter_double).to receive_messages(
+      absolute_payload: absolute_payload,
+      relative_path: relative_path
+    )
+    allow(presenter_class).to receive(:new).and_return(presenter_double)
+    presenter_double
+  end
+end

data/spec/table_format_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::CoverageCLI, 'table format for all commands' do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+
+  def run_cli(*argv)
+    cli = SimpleCovMcp::CoverageCLI.new
+    output = nil
+    silence_output do |stdout, _stderr|
+      cli.send(:run, argv)
+      output = stdout.string
+    end
+    output
+  end
+
+  describe 'table format consistency' do
+    it 'list command produces formatted table' do
+      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'table', 'list')
+      expect(output).to include('│')  # Box drawing character
+      expect(output).to include('File')
+      expect(output).to include('%')
+    end
+
+    it 'summary command produces formatted table' do
+      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'table',
+        'summary', 'lib/foo.rb')
+      expect(output).to include('│')  # Box drawing character
+      expect(output).to include('File')
+      expect(output).to include('%')
+    end
+
+    it 'totals command produces formatted table' do
+      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'table', 'totals')
+      expect(output).to include('│')  # Box drawing character
+      expect(output).to include('Lines')
+      expect(output).to include('%')
+    end
+
+    it 'detailed command produces formatted table' do
+      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'table',
+        'detailed', 'lib/foo.rb')
+      expect(output).to include('│')  # Box drawing character
+      expect(output).to include('Line')
+      expect(output).to include('Hits')
+    end
+
+    it 'uncovered command produces formatted table' do
+      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'table',
+        'uncovered', 'lib/bar.rb')  # bar.rb has uncovered lines
+      expect(output).to include('│')  # Box drawing character
+      expect(output).to include('Line')
+    end
+
+    it 'raw command produces formatted table' do
+      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'table',
+        'raw', 'lib/foo.rb')
+      expect(output).to include('│')  # Box drawing character
+      expect(output).to include('Line')
+      expect(output).to include('Coverage')
+    end
+
+    it 'version command produces formatted table' do
+      output = run_cli('--format', 'table', 'version')
+      expect(output).to include('│')  # Box drawing character
+      expect(output).to include('Version')
+    end
+  end
+end

data/spec/tools/validate_tool_spec.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'pathname'
+require 'tempfile'
+require 'simplecov_mcp/tools/validate_tool'
+
+RSpec.describe SimpleCovMcp::Tools::ValidateTool do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:resultset) { 'coverage' }
+  let(:server_context) { instance_double('ServerContext').as_null_object }
+
+  before do
+    setup_mcp_response_stub
+  end
+
+  def call_tool(**params)
+    described_class.call(**params, root: root, resultset: resultset, server_context: server_context)
+  end
+
+  def response_text(response)
+    item = response.payload.first
+    item['text']
+  end
+
+  def with_predicate_file(content, dir: nil)
+    Tempfile.create(['predicate', '.rb'], dir) do |file|
+      file.write(content)
+      file.flush
+      yield file
+    end
+  end
+
+  shared_examples 'syntax error handling' do |_source, error_message_fragment|
+    it 'returns an error for syntax errors' do
+      response = call_with_predicate('->(_m) { 1 + }')
+
+      expect(response_text(response)).to include(error_message_fragment)
+    end
+  end
+
+  shared_examples 'non-callable handling' do |_source, content|
+    it 'returns an error when the predicate is not callable' do
+      response = call_with_predicate(content)
+
+      expect(response_text(response)).to include('Predicate must be callable')
+    end
+  end
+
+  shared_examples 'false result' do
+    it 'returns false when the predicate evaluates to false' do
+      response = call_with_predicate('->(_m) { false }')
+
+      data, = expect_mcp_text_json(response, expected_keys: ['result'])
+      expect(data['result']).to be(false)
+    end
+  end
+
+  describe '.call' do
+    context 'with inline code' do
+      def call_with_predicate(code)
+        call_tool(code: code)
+      end
+
+      it 'evaluates the predicate against the coverage model' do
+        expect(SimpleCovMcp::CoverageModel).to receive(:new).and_call_original
+
+        # Realistic coverage policy: foo.rb must have at least 50% coverage
+        response = call_with_predicate(
+          '->(m) { m.all_files.detect { |f| f["file"].include?("foo.rb") }["percentage"] >= 50.0 }'
+        )
+
+        data, = expect_mcp_text_json(response, expected_keys: ['result'])
+        expect(data['result']).to be(true)
+      end
+
+      it_behaves_like 'false result'
+      it_behaves_like 'syntax error handling', :code, 'Syntax error in predicate code'
+      it_behaves_like 'non-callable handling', :code, '123'
+
+      it 'returns an error when the predicate raises during execution' do
+        response = call_with_predicate("->(_m) { raise 'Boom' }")
+
+        text = response_text(response)
+        expect(text).to include('Error:', 'Boom')
+        # Verify it's an error response, not a JSON result
+        expect(text).not_to match(/\{"result"/)
+      end
+    end
+
+    context 'with a predicate file' do
+      def call_with_predicate(content)
+        with_predicate_file(content) do |file|
+          call_tool(file: file.path)
+        end
+      end
+
+      it_behaves_like 'false result'
+      it_behaves_like 'syntax error handling', :file, 'Syntax error in predicate file'
+      it_behaves_like 'non-callable handling', :file, 'true'
+
+      it 'expands relative paths from the provided root before evaluation' do
+        with_predicate_file('->(_m) { true }', dir: root) do |file|
+          relative_path = Pathname.new(file.path).relative_path_from(Pathname.new(root)).to_s
+          allow(SimpleCovMcp::PredicateEvaluator)
+            .to receive(:evaluate_file)
+            .and_return(true)
+
+          response = call_tool(file: relative_path)
+
+          expect(SimpleCovMcp::PredicateEvaluator)
+            .to have_received(:evaluate_file)
+            .with(file.path, kind_of(SimpleCovMcp::CoverageModel))
+          data, = expect_mcp_text_json(response, expected_keys: ['result'])
+          expect(data['result']).to be(true)
+        end
+      end
+
+      it 'returns an error when the predicate file is missing' do
+        response = call_tool(file: 'missing_predicate.rb')
+
+        expect(response_text(response)).to include('Predicate file not found')
+      end
+    end
+
+    it 'returns an error when neither code nor file is provided' do
+      response = call_tool
+
+      expect(response_text(response)).to include("Either 'code' or 'file' must be provided")
+    end
+  end
+end