cov-loupe 3.0.0

data/spec/coverage_reporter_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CovLoupe::CoverageReporter do
+  let(:model) { instance_double(CovLoupe::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 CovLoupe::CoverageReporter }
+      expect(klass.private_instance_methods).to include(:report)
+    end
+  end
+end

data/spec/coverage_table_tool_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'cov_loupe/tools/coverage_table_tool'
+
+RSpec.describe CovLoupe::Tools::CoverageTableTool do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:server_context) { instance_double('ServerContext').as_null_object }
+
+  before do
+    setup_mcp_response_stub
+  end
+
+  def run_tool(staleness: :off)
+    # Let real CoverageModel work to test actual format_table behavior
+    described_class.call(root: root, staleness: staleness,
+      server_context: server_context).payload.first['text']
+  end
+
+  it 'returns a formatted table as a string' do
+    output = run_tool
+
+    # Contains table structure, headers, and file data
+    expect(output).to include(
+      '┌', '┬', '┐', '│', '├', '┼', '┤', '└', '┴', '┘',
+      'File', 'Covered', 'Total', ' │ Stale │',
+      'lib/foo.rb', 'lib/bar.rb',
+      'Files: total 2, ok 0, stale 2'
+    )
+  end
+
+  it 'configures CLI to enforce stale checking when requested' do
+    model = instance_double(CovLoupe::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(CovLoupe::CoverageModel).to receive(:new).with(
+      root: root,
+      resultset: nil,
+      staleness: :error,
+      tracked_globs: nil
+    ).and_return(model)
+    allow(model).to receive(:format_table).and_return('Mock table output')
+
+    described_class.call(root: root, staleness: :error, server_context: server_context)
+
+    expect(CovLoupe::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 'cov_loupe/tools/coverage_totals_tool'
+
+RSpec.describe CovLoupe::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(CovLoupe::CoverageModel)
+    allow(CovLoupe::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(CovLoupe::Presenters::ProjectTotalsPresenter)
+    allow(CovLoupe::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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CovLoupe::ErrorHandler do
+  subject(:handler) { described_class.new(error_mode: :log, logger: logger) }
+
+  let(:logger) do
+    Class.new do
+      attr_reader :messages
+
+      def initialize = @messages = []
+      def error(msg) = @messages << msg
+    end.new
+  end
+
+
+  it 'maps filesystem errors to friendly custom errors' do
+    e = handler.convert_standard_error(Errno::EISDIR.new('Is a directory @ rb_sysopen - a_dir'))
+    expect(e).to be_a(CovLoupe::NotAFileError)
+
+    e = handler.convert_standard_error(
+      Errno::ENOENT.new('No such file or directory @ rb_sysopen - missing.txt')
+    )
+    expect(e).to be_a(CovLoupe::FileNotFoundError)
+
+    e = handler.convert_standard_error(Errno::EACCES.new('Permission denied @ rb_sysopen - secret'))
+    expect(e).to be_a(CovLoupe::FilePermissionError)
+  end
+
+  it 'maps JSON::ParserError to CoverageDataError' do
+    e = handler.convert_standard_error(JSON::ParserError.new('unexpected token'))
+    expect(e).to be_a(CovLoupe::CoverageDataError)
+    expect(e.user_friendly_message).to include('Invalid coverage data format')
+  end
+
+  it 'maps ArgumentError by message' do
+    e = handler.convert_standard_error(
+      ArgumentError.new('wrong number of arguments (given 1, expected 2)')
+    )
+    expect(e).to be_a(CovLoupe::UsageError)
+
+    e = handler.convert_standard_error(ArgumentError.new('invalid option'))
+    expect(e).to be_a(CovLoupe::ConfigurationError)
+  end
+
+  it 'maps NoMethodError to CoverageDataError with helpful info' do
+    e = handler.convert_standard_error(
+      NoMethodError.new("undefined method `fetch' for #<Hash:0x123>")
+    )
+    expect(e).to be_a(CovLoupe::CoverageDataError)
+    expect(e.user_friendly_message).to include('Invalid coverage data structure')
+  end
+
+  it 'maps runtime strings from util to friendly errors' do
+    e = handler.convert_standard_error(
+      RuntimeError.new('Could not find .resultset.json under /path; run tests')
+    )
+    expect(e).to be_a(CovLoupe::CoverageDataError)
+    expect(e.user_friendly_message).to include('run your tests first')
+
+    e = handler.convert_standard_error(
+      RuntimeError.new('No .resultset.json found in directory: /path')
+    )
+    expect(e).to be_a(CovLoupe::CoverageDataError)
+
+    e = handler.convert_standard_error(
+      RuntimeError.new('Specified resultset not found: /nowhere/file.json')
+    )
+    expect(e).to be_a(CovLoupe::ResultsetNotFoundError)
+  end
+
+  it 'logs via provided logger' do
+    begin
+      handler.handle_error(Errno::ENOENT.new('No such file or directory @ rb_sysopen - x'),
+        context: 'test', reraise: false)
+    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(CovLoupe::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(CovLoupe::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(CovLoupe::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(CovLoupe::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(CovLoupe::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(CovLoupe::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(CovLoupe::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 CovLoupe::Error when reraise is true' do
+      error = CovLoupe::FileNotFoundError.new('Test file not found')
+
+      expect { handler.handle_error(error, context: 'test', reraise: true) }
+        .to raise_error(CovLoupe::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(CovLoupe::FileNotFoundError)
+
+      # Verify it was logged
+      expect(logger.messages.join).to include('Error in test')
+    end
+  end
+end

data/spec/error_mode_spec.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Error Mode System' do
+  let(:test_logger) do
+    Class.new do
+      attr_reader :messages
+
+      def initialize = @messages = []
+      def error(msg) = @messages << msg
+    end.new
+  end
+
+  let(:test_error) { StandardError.new('Test error message') }
+
+  describe 'ErrorHandler error modes' do
+    context 'with error_mode: :off' do
+      subject(:handler) { CovLoupe::ErrorHandler.new(error_mode: :off, logger: test_logger) }
+
+      it 'does not log errors' do
+        expect(handler.log_errors?).to be false
+        expect(handler.show_stack_traces?).to be false
+
+        handler.handle_error(test_error, context: 'test', reraise: false)
+        expect(test_logger.messages).to be_empty
+      end
+    end
+
+    context 'with error_mode: :log' do
+      subject(:handler) { CovLoupe::ErrorHandler.new(error_mode: :log, logger: test_logger) }
+
+      it 'logs errors but not stack traces' do
+        expect(handler.log_errors?).to be true
+        expect(handler.show_stack_traces?).to be false
+
+        handler.handle_error(test_error, context: 'test', reraise: false)
+        logged_message = test_logger.messages.join
+        expect(logged_message).to include('Error in test: StandardError: Test error message')
+        expect(logged_message).not_to include('spec/error_mode_spec.rb') # No stack trace
+      end
+    end
+
+    context 'with error_mode: :debug' do
+      subject(:handler) { CovLoupe::ErrorHandler.new(error_mode: :debug, logger: test_logger) }
+
+      it 'logs errors with stack traces' do
+        expect(handler.log_errors?).to be true
+        expect(handler.show_stack_traces?).to be true
+
+        # Create an error with a proper backtrace
+        begin
+          raise StandardError, 'Test error message'
+        rescue => e
+          handler.handle_error(e, context: 'test', reraise: false)
+        end
+
+        logged_message = test_logger.messages.join
+        expect(logged_message).to include('Error in test: StandardError: Test error message')
+        expect(logged_message).to include('spec/error_mode_spec.rb') # Stack trace included
+      end
+    end
+  end
+
+  describe 'ErrorHandlerFactory' do
+    it 'creates handlers with correct modes' do
+      cli_handler = CovLoupe::ErrorHandlerFactory.for_cli(error_mode: :debug)
+      expect(cli_handler.error_mode).to eq(:debug)
+
+      lib_handler = CovLoupe::ErrorHandlerFactory.for_library(error_mode: :off)
+      expect(lib_handler.error_mode).to eq(:off)
+
+      mcp_handler = CovLoupe::ErrorHandlerFactory.for_mcp_server(error_mode: :log)
+      expect(mcp_handler.error_mode).to eq(:log)
+    end
+  end
+
+  describe 'MCP Tools error mode support' do
+    before { setup_mcp_response_stub }
+
+    it 'BaseTool.handle_mcp_error respects error modes' do
+      test_error = StandardError.new('Test MCP error')
+
+      # Test different error modes
+      [:off, :log, :debug].each do |mode|
+        expect(CovLoupe::ErrorHandlerFactory)
+          .to receive(:for_mcp_server).with(error_mode: mode).and_call_original
+
+        response = CovLoupe::BaseTool.handle_mcp_error(test_error, 'TestTool', error_mode: mode)
+        expect(response).to be_a(MCP::Tool::Response)
+        expect(response.payload.first['text']).to include('Error:')
+      end
+    end
+  end
+
+  describe 'CLI error mode support' do
+    let(:project_dir) { File.join(__dir__, 'fixtures', 'project1') }
+
+    it 'accepts --error-mode flag' do
+      cli = CovLoupe::CoverageCLI.new
+
+      # Test that the option parser accepts the flag
+      expect do
+        cli.send(:parse_options!, ['--error-mode', 'debug', 'summary', 'lib/foo.rb'])
+      end.not_to raise_error
+
+      expect(cli.config.error_mode).to eq(:debug)
+    end
+
+    it 'creates error handler with specified mode' do
+      cli = CovLoupe::CoverageCLI.new
+      cli.send(:parse_options!, ['--error-mode', 'off', 'summary', 'lib/foo.rb'])
+
+      expect(cli.send(:error_handler).error_mode).to eq(:off)
+    end
+
+    it 'validates error mode values' do
+      cli = CovLoupe::CoverageCLI.new
+
+      expect do
+        cli.send(:parse_options!, ['--error-mode', 'invalid', 'summary', 'lib/foo.rb'])
+      end.to raise_error(OptionParser::InvalidArgument)
+    end
+  end
+
+  describe 'Error mode validation' do
+    it 'raises ArgumentError for invalid error modes' do
+      expect do
+        CovLoupe::ErrorHandler.new(error_mode: :invalid)
+      end.to raise_error(ArgumentError, /Invalid error_mode: :invalid/)
+    end
+
+    it 'accepts all valid error modes' do
+      expect { CovLoupe::ErrorHandler.new(error_mode: :off) }.not_to raise_error
+      expect { CovLoupe::ErrorHandler.new(error_mode: :log) }.not_to raise_error
+      expect { CovLoupe::ErrorHandler.new(error_mode: :debug) }.not_to raise_error
+    end
+  end
+end