cov-loupe 3.0.0

data/spec/support/mcp_runner.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'timeout'
+require 'json'
+
+module Spec
+  module Support
+    module McpRunner
+      # Thin wrapper around `Open3.popen3` that standardizes how the integration
+      # specs talk to the `cov-loupe` executable. It accepts either a single
+      # JSON-RPC request hash, a sequence of requests, or raw string input,
+      # writes them to the subprocess stdin (ensuring a trailing newline), then
+      # collects stdout, stderr, and the exit status with a timeout. The helper
+      # 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,
+        close_stdin: true)
+        payload = build_payload(requests, input)
+
+        stdout_str = ''
+        stderr_str = ''
+        status = nil
+
+        Open3.popen3(env, 'ruby', '-I', lib_path, exe_path) do |stdin, stdout, stderr, wait_thr|
+          unless payload.nil?
+            stdin.write(payload)
+            stdin.write("\n") if !payload.empty? && !payload.end_with?("\n")
+          end
+          stdin.close if close_stdin
+
+          Timeout.timeout(timeout) do
+            stdout_str = stdout.read
+            stderr_str = stderr.read
+            status = wait_thr.value
+          end
+        end
+
+        { stdout: stdout_str, stderr: stderr_str, status: status }
+      rescue Timeout::Error
+        raise "MCP server timed out after #{timeout} seconds"
+      end
+
+      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
+
+      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
+
+      module_function def build_payload(requests, input)
+        return input unless requests
+
+        normalized = requests.is_a?(Array) ? requests : [requests]
+        normalized.map { |req| req.is_a?(String) ? req : JSON.generate(req) }.join("\n")
+      end
+      private_class_method :build_payload
+    end
+  end
+end

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(CovLoupe::StalenessChecker)
+    allow(checker_double).to receive_messages(
+      stale_for_file?: value,
+      off?: false
+    )
+    allow(checker_double).to receive(:check_file!)
+    allow(CovLoupe::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., CovLoupe::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 CovLoupe::CoverageCLI, 'table format for all commands' do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+
+  def run_cli(*argv)
+    cli = CovLoupe::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 'cov_loupe/tools/validate_tool'
+
+RSpec.describe CovLoupe::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(CovLoupe::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(CovLoupe::PredicateEvaluator)
+            .to receive(:evaluate_file)
+            .and_return(true)
+
+          response = call_tool(file: relative_path)
+
+          expect(CovLoupe::PredicateEvaluator)
+            .to have_received(:evaluate_file)
+            .with(file.path, kind_of(CovLoupe::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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'cov_loupe/tools/help_tool'
+require 'cov_loupe/tools/version_tool'
+require 'cov_loupe/tools/coverage_summary_tool'
+require 'cov_loupe/tools/coverage_raw_tool'
+require 'cov_loupe/tools/uncovered_lines_tool'
+require 'cov_loupe/tools/coverage_detailed_tool'
+require 'cov_loupe/tools/coverage_totals_tool'
+
+RSpec.describe CovLoupe::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
+  # 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 CovLoupe::Tools::HelpTool do
+    it 'returns tool information without errors' do
+      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')
+
+      data = JSON.parse(item['text'])
+      expect(data).to have_key('tools')
+      expect(data['tools']).not_to be_empty
+    end
+  end
+
+  describe CovLoupe::Tools::CoverageSummaryTool do
+    it 'handles errors during model creation' do
+      allow(CovLoupe::CoverageModel).to receive(:new).and_raise(StandardError, 'Model error')
+
+      response = described_class.call(
+        path: 'lib/foo.rb',
+        error_mode: 'log',
+        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']).to include('Error')
+    end
+  end
+
+  describe CovLoupe::Tools::CoverageRawTool do
+    it 'handles errors during raw data retrieval' do
+      model = instance_double(CovLoupe::CoverageModel)
+      allow(CovLoupe::CoverageModel).to receive(:new).and_return(model)
+      allow(model).to receive(:raw_for).and_raise(StandardError, 'Raw data error')
+
+      response = described_class.call(
+        path: 'lib/foo.rb',
+        error_mode: 'log',
+        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']).to include('Error')
+    end
+  end
+
+  describe CovLoupe::Tools::UncoveredLinesTool do
+    it 'handles errors during uncovered lines retrieval' do
+      model = instance_double(CovLoupe::CoverageModel)
+      allow(CovLoupe::CoverageModel).to receive(:new).and_return(model)
+      allow(model).to receive(:uncovered_for).and_raise(StandardError, 'Uncovered error')
+
+      response = described_class.call(
+        path: 'lib/foo.rb',
+        error_mode: 'log',
+        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']).to include('Error')
+    end
+  end
+
+  describe CovLoupe::Tools::CoverageDetailedTool do
+    it 'handles errors during detailed data retrieval' do
+      model = instance_double(CovLoupe::CoverageModel)
+      allow(CovLoupe::CoverageModel).to receive(:new).and_return(model)
+      allow(model).to receive(:detailed_for).and_raise(StandardError, 'Detailed error')
+
+      response = described_class.call(
+        path: 'lib/foo.rb',
+        error_mode: 'log',
+        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']).to include('Error')
+    end
+  end
+
+  describe CovLoupe::Tools::CoverageTotalsTool do
+    it 'handles errors during totals calculation' do
+      allow(CovLoupe::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

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tempfile'
+
+RSpec.describe CovLoupe::CovUtil do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:resultset_file) { File.join(root, 'coverage', '.resultset.json') }
+
+
+
+  it 'lookup_lines supports cwd-stripping' do
+    lines = [1, 0]
+
+    # Exact key
+    cov = { '/abs/path/foo.rb' => { 'lines' => lines } }
+    expect(described_class.lookup_lines(cov, '/abs/path/foo.rb')).to eq(lines)
+
+    # CWD strip fallback
+    allow(Dir).to receive(:pwd).and_return('/cwd')
+    cov = { 'sub/foo.rb' => { 'lines' => lines } }
+    expect(described_class.lookup_lines(cov, '/cwd/sub/foo.rb')).to eq(lines)
+
+    # Different paths with same basename should not match
+    cov = { '/some/where/else/foo.rb' => { 'lines' => lines } }
+    expect do
+      described_class.lookup_lines(cov, '/another/place/foo.rb')
+    end.to raise_error(CovLoupe::FileError, /No coverage entry found/)
+
+    # Missing raises a FileError
+    cov = {}
+    expect do
+      described_class.lookup_lines(cov, '/nowhere/foo.rb')
+    end.to raise_error(CovLoupe::FileError, /No coverage entry found/)
+  end
+
+  it 'summary handles edge cases and coercion' do
+    expect(described_class.summary([]))
+      .to include('percentage' => 100.0, 'total' => 0, 'covered' => 0)
+    expect(described_class.summary([nil, nil]))
+      .to include('percentage' => 100.0, 'total' => 0, 'covered' => 0)
+    expect(described_class.summary(['1', '0', nil]))
+      .to include('percentage' => 50.0, 'total' => 2, 'covered' => 1)
+  end
+
+  it 'uncovered and detailed ignore nils' do
+    arr = [1, 0, nil, 2]
+    expect(described_class.uncovered(arr)).to eq([2])
+    expect(described_class.detailed(arr)).to eq([
+      { 'line' => 1, 'hits' => 1, 'covered' => true },
+      { 'line' => 2, 'hits' => 0, 'covered' => false },
+      { 'line' => 4, 'hits' => 2, 'covered' => true }
+    ])
+  end
+
+  it 'load_coverage raises CoverageDataError on invalid JSON via model' do
+    Dir.mktmpdir do |dir|
+      bad = File.join(dir, '.resultset.json')
+      File.write(bad, '{not-json')
+      expect do
+        CovLoupe::CoverageModel.new(root: root, resultset: dir)
+      end.to raise_error(CovLoupe::CoverageDataError, /Invalid coverage data format/)
+    end
+  end
+
+  describe 'logging configuration' do
+    let(:test_message) { 'test log message' }
+
+    around do |example|
+      # Reset logging settings so each example starts clean.
+      old_default = CovLoupe.default_log_file
+      old_active = CovLoupe.active_log_file
+      CovLoupe.default_log_file = nil
+      CovLoupe.active_log_file = nil
+
+      example.run
+
+      # Restore state
+      CovLoupe.default_log_file = old_default
+      CovLoupe.active_log_file = old_active
+    end
+
+
+
+    it "logs to stdout when active_log_file is 'stdout'" do
+      CovLoupe.active_log_file = 'stdout'
+      expect(File).not_to receive(:open)
+      expect { described_class.log(test_message) }
+        .to output(/#{Regexp.escape(test_message)}/).to_stdout
+    end
+
+    it "logs to stderr when active_log_file is 'stderr'" do
+      CovLoupe.active_log_file = 'stderr'
+      expect(File).not_to receive(:open)
+      expect { described_class.log(test_message) }
+        .to output(/#{Regexp.escape(test_message)}/).to_stderr
+    end
+
+    it 'log writes to file when path is configured' do
+      tmp = Tempfile.new('cov_loupe-log')
+      log_path = tmp.path
+      tmp.close
+
+      CovLoupe.active_log_file = log_path
+
+      described_class.log(test_message)
+
+      expect(File.exist?(log_path)).to be true
+      content = File.read(log_path)
+      expect(content).to include(test_message)
+      expect(content).to match(TIMESTAMP_REGEX)
+    ensure
+      tmp&.unlink
+    end
+
+    it 'log respects runtime changes disabling logging mid-run' do
+      tmp = Tempfile.new('cov_loupe-log')
+      log_path = tmp.path
+      tmp.close
+
+      CovLoupe.active_log_file = log_path
+
+      described_class.log('first entry')
+      expect(File.exist?(log_path)).to be true
+      first_content = File.read(log_path)
+      expect(first_content).to include('first entry')
+
+      CovLoupe.active_log_file = 'stderr'
+
+      expect { described_class.log('second entry') }
+        .to output(/second entry/).to_stderr
+      expect(File.exist?(log_path)).to be true
+      expect(File.read(log_path)).to eq(first_content)
+    ensure
+      tmp&.unlink
+    end
+
+    it 'exposes default log file configuration separately' do
+      original_default = CovLoupe.default_log_file
+      CovLoupe.default_log_file = 'stderr'
+      expect(CovLoupe.default_log_file).to eq('stderr')
+      expect(CovLoupe.active_log_file).to eq('stderr')
+    ensure
+      CovLoupe.default_log_file = original_default
+    end
+
+    it 'allows adjusting the active log target without touching the default' do
+      original_default = CovLoupe.default_log_file
+      CovLoupe.active_log_file = 'stdout'
+      expect(CovLoupe.active_log_file).to eq('stdout')
+      expect(CovLoupe.default_log_file).to eq(original_default)
+    end
+  end
+end