simplecov-mcp 1.0.1 → 2.0.1

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

data/spec/tools_error_handling_spec.rb

@@ -7,60 +7,30 @@ require 'simplecov_mcp/tools/coverage_summary_tool'
 require 'simplecov_mcp/tools/coverage_raw_tool'
 require 'simplecov_mcp/tools/uncovered_lines_tool'
 require 'simplecov_mcp/tools/coverage_detailed_tool'
+require 'simplecov_mcp/tools/coverage_totals_tool'
 
-RSpec.describe 'MCP Tool error handling' do
+RSpec.describe SimpleCovMcp::Tools do
   let(:server_context) { instance_double('ServerContext').as_null_object }
 
   before do
     setup_mcp_response_stub
   end
 
-  # Note: VersionTool error handling is difficult to test because the tool is so simple
+  # NOTE: VersionTool error handling is difficult to test because the tool is so simple
   # and doesn't have any complex logic that could fail. The rescue clause in the tool
   # exists for consistency with other tools but is unlikely to be triggered in practice.
 
   describe SimpleCovMcp::Tools::HelpTool do
-    it 'handles errors during query processing' do
-      # Simulate an error during filter_entries
-      allow(described_class).to receive(:filter_entries).and_raise(StandardError, 'Filter error')
+    it 'returns tool information without errors' do
+      response = described_class.call(error_mode: 'log', server_context: server_context)
 
-      response = described_class.call(query: 'test', error_mode: 'on',
-        server_context: server_context)
-
-      # Should return error response
       expect(response).to be_a(MCP::Tool::Response)
       item = response.payload.first
       expect(item[:type] || item['type']).to eq('text')
-      expect(item[:text] || item['text']).to include('Error')
-    end
-
-    it 'returns empty array when tokens are empty after filtering' do
-      # Test the edge case where query contains only non-word characters
-      response = described_class.call(query: '!!!', server_context: server_context)
-
-      data = JSON.parse(response.payload.first['text'])
-      # With empty tokens, should return all entries (no filtering applied)
-      expect(data['tools']).not_to be_empty
-    end
 
-    it 'handles non-string, non-array values in filter' do
-      # Test value_matches? with values that are neither strings nor arrays
-      # This exercises the 'else false' branch
-      allow(described_class).to receive(:format_entry).and_return({
-        'tool' => 'test_tool',
-        'label' => nil, # Neither string nor array
-        'use_when' => 123, # Neither string nor array
-        'avoid_when' => true, # Neither string nor array
-        'inputs' => {}, # Neither string nor array
-        'example' => 'example'
-      })
-
-      response = described_class.call(query: 'test', server_context: server_context)
-
-      # Should not crash, should return response
-      expect(response).to be_a(MCP::Tool::Response)
-      data = JSON.parse(response.payload.first['text'])
+      data = JSON.parse(item['text'])
       expect(data).to have_key('tools')
+      expect(data['tools']).not_to be_empty
     end
   end
 
@@ -70,7 +40,7 @@ RSpec.describe 'MCP Tool error handling' do
 
       response = described_class.call(
         path: 'lib/foo.rb',
-        error_mode: 'on',
+        error_mode: 'log',
         server_context: server_context
       )
 
@@ -78,7 +48,7 @@ RSpec.describe 'MCP Tool error handling' do
       expect(response).to be_a(MCP::Tool::Response)
       item = response.payload.first
       expect(item[:type] || item['type']).to eq('text')
-      expect(item[:text] || item['text']).to include('Error')
+      expect(item['text']).to include('Error')
     end
   end
 
@@ -88,9 +58,9 @@ RSpec.describe 'MCP Tool error handling' do
       allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
       allow(model).to receive(:raw_for).and_raise(StandardError, 'Raw data error')
 
-      response = SimpleCovMcp::Tools::CoverageRawTool.call(
+      response = described_class.call(
         path: 'lib/foo.rb',
-        error_mode: 'on',
+        error_mode: 'log',
         server_context: server_context
       )
 
@@ -98,7 +68,7 @@ RSpec.describe 'MCP Tool error handling' do
       expect(response).to be_a(MCP::Tool::Response)
       item = response.payload.first
       expect(item[:type] || item['type']).to eq('text')
-      expect(item[:text] || item['text']).to include('Error')
+      expect(item['text']).to include('Error')
     end
   end
 
@@ -108,9 +78,9 @@ RSpec.describe 'MCP Tool error handling' do
       allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
       allow(model).to receive(:uncovered_for).and_raise(StandardError, 'Uncovered error')
 
-      response = SimpleCovMcp::Tools::UncoveredLinesTool.call(
+      response = described_class.call(
         path: 'lib/foo.rb',
-        error_mode: 'on',
+        error_mode: 'log',
         server_context: server_context
       )
 
@@ -118,7 +88,7 @@ RSpec.describe 'MCP Tool error handling' do
       expect(response).to be_a(MCP::Tool::Response)
       item = response.payload.first
       expect(item[:type] || item['type']).to eq('text')
-      expect(item[:text] || item['text']).to include('Error')
+      expect(item['text']).to include('Error')
     end
   end
 
@@ -128,9 +98,9 @@ RSpec.describe 'MCP Tool error handling' do
       allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
       allow(model).to receive(:detailed_for).and_raise(StandardError, 'Detailed error')
 
-      response = SimpleCovMcp::Tools::CoverageDetailedTool.call(
+      response = described_class.call(
         path: 'lib/foo.rb',
-        error_mode: 'on',
+        error_mode: 'log',
         server_context: server_context
       )
 
@@ -138,7 +108,23 @@ RSpec.describe 'MCP Tool error handling' do
       expect(response).to be_a(MCP::Tool::Response)
       item = response.payload.first
       expect(item[:type] || item['type']).to eq('text')
-      expect(item[:text] || item['text']).to include('Error')
+      expect(item['text']).to include('Error')
+    end
+  end
+
+  describe SimpleCovMcp::Tools::CoverageTotalsTool do
+    it 'handles errors during totals calculation' do
+      allow(SimpleCovMcp::CoverageModel).to receive(:new).and_raise(StandardError, 'Model error')
+
+      response = described_class.call(
+        error_mode: 'log',
+        server_context: server_context
+      )
+
+      expect(response).to be_a(MCP::Tool::Response)
+      item = response.payload.first
+      expect(item[:type] || item['type']).to eq('text')
+      expect(item['text']).to include('Error')
     end
   end
 end

data/spec/util_spec.rb

@@ -35,11 +35,12 @@ RSpec.describe SimpleCovMcp::CovUtil do
   end
 
   it 'summary handles edge cases and coercion' do
-    expect(described_class.summary([])).to include('pct' => 100.0, 'total' => 0, 'covered' => 0)
+    expect(described_class.summary([]))
+      .to include('percentage' => 100.0, 'total' => 0, 'covered' => 0)
     expect(described_class.summary([nil, nil]))
-      .to include('pct' => 100.0, 'total' => 0, 'covered' => 0)
+      .to include('percentage' => 100.0, 'total' => 0, 'covered' => 0)
     expect(described_class.summary(['1', '0', nil]))
-      .to include('pct' => 50.0, 'total' => 2, 'covered' => 1)
+      .to include('percentage' => 50.0, 'total' => 2, 'covered' => 1)
   end
 
   it 'uncovered and detailed ignore nils' do
@@ -65,7 +66,7 @@ RSpec.describe SimpleCovMcp::CovUtil do
   describe 'logging configuration' do
     let(:test_message) { 'test log message' }
 
-    around(:each) do |example|
+    around do |example|
       # Reset logging settings so each example starts clean.
       old_default = SimpleCovMcp.default_log_file
       old_active = SimpleCovMcp.active_log_file