cov-loupe 3.0.0 → 4.0.0.pre

data/spec/cov_loupe_opts_spec.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'COV_LOUPE_OPTS Environment Variable' do
-  let(:cli) { CovLoupe::CoverageCLI.new }
-
-  around do |example|
-    original_value = ENV['COV_LOUPE_OPTS']
-    example.run
-  ensure
-    ENV['COV_LOUPE_OPTS'] = original_value
-  end
-
-  describe 'CLI option parsing from environment' do
-    it 'parses simple options from COV_LOUPE_OPTS' do
-      ENV['COV_LOUPE_OPTS'] = '--error-mode off --format json'
-      env_opts = CovLoupe.send(:extract_env_opts)
-
-      swallow_system_exit do
-        silence_output do
-          cli.send(:run, env_opts + ['summary', 'lib/foo.rb'])
-        end
-      end
-    rescue CovLoupe::Error => e
-      # Expected to fail due to missing file, but options should be parsed
-      puts "DEBUG: Caught exception: #{e.class}: #{e.message}" if ENV['DEBUG']
-    ensure
-      expect(cli.config.error_mode).to eq(:off)
-      expect(cli.config.format).to eq(:json)
-    end
-
-    it 'handles quoted options with spaces' do
-      test_path = File.join(Dir.tmpdir, 'test path with spaces', '.resultset.json')
-      ENV['COV_LOUPE_OPTS'] = "--resultset \"#{test_path}\""
-      env_opts = CovLoupe.send(:extract_env_opts)
-
-      exit_status = swallow_system_exit do
-        silence_output do
-          cli.send(:run, env_opts + ['--help'])
-        end
-      end
-
-      expect(exit_status).to eq(0) # --help exits cleanly
-      expect(cli.config.resultset).to eq(test_path)
-    end
-
-    it 'supports setting log-file to stdout from environment' do
-      ENV['COV_LOUPE_OPTS'] = '--log-file stdout'
-      env_opts = CovLoupe.send(:extract_env_opts)
-
-      swallow_system_exit do
-        silence_output do
-          cli.send(:run, env_opts + ['--help'])
-        end
-      end
-
-      expect(cli.config.log_file).to eq('stdout')
-    end
-
-    it 'command line arguments override environment options' do
-      ENV['COV_LOUPE_OPTS'] = '--error-mode off'
-      env_opts = CovLoupe.send(:extract_env_opts)
-
-      begin
-        args = env_opts + ['--error-mode', 'debug', 'summary', 'lib/foo.rb']
-        silence_output { cli.send(:run, args) }
-      rescue SystemExit, CovLoupe::Error
-        # Expected to fail, but options should be parsed
-      end
-
-      # Command line should override environment
-      expect(cli.config.error_mode).to eq(:debug)
-    end
-
-    it 'handles malformed COV_LOUPE_OPTS gracefully' do
-      ENV['COV_LOUPE_OPTS'] = '--option "unclosed quote'
-
-      # Should catch the ConfigurationError and exit cleanly
-      _out, _err, status = run_cli_with_status('summary', 'lib/foo.rb')
-      expect(status).not_to eq(0)
-    end
-
-    it 'returns empty array when COV_LOUPE_OPTS is not set' do
-      # ENV is already cleared by around block
-      opts = CovLoupe.send(:extract_env_opts)
-      expect(opts).to eq([])
-    end
-
-    it 'returns empty array when COV_LOUPE_OPTS is empty' do
-      ENV['COV_LOUPE_OPTS'] = ''
-      opts = CovLoupe.send(:extract_env_opts)
-      expect(opts).to eq([])
-    end
-  end
-
-  describe 'CLI mode detection with COV_LOUPE_OPTS' do
-    it 'respects --force-cli from environment variable' do
-      ENV['COV_LOUPE_OPTS'] = '--force-cli'
-
-      # This would normally be MCP mode (no TTY, no subcommand)
-      stdin = double('stdin', tty?: false)
-
-      env_opts = CovLoupe.send(:extract_env_opts)
-      full_argv = env_opts + []
-
-      expect(CovLoupe::ModeDetector.cli_mode?(full_argv, stdin: stdin)).to be true
-    end
-
-    it 'handles parse errors gracefully in mode detection' do
-      ENV['COV_LOUPE_OPTS'] = '--option "unclosed quote'
-
-      # Should return empty array and not crash
-      opts = CovLoupe.send(:extract_env_opts)
-      expect(opts).to eq([])
-    end
-
-    it 'actually runs CLI when --force-cli is in COV_LOUPE_OPTS' do
-      ENV['COV_LOUPE_OPTS'] = '--force-cli'
-
-      # Mock STDIN to not be a TTY (would normally trigger MCP server mode)
-      allow($stdin).to receive(:tty?).and_return(false)
-
-      # Run with --help which should produce help output
-      output = nil
-      silence_output do |out, err|
-        swallow_system_exit do
-          CovLoupe.run(['--help'])
-        end
-        output = out.string + err.string
-      end
-
-      # Verify CLI actually ran by checking for help text
-      expect(output).to include('Usage:')
-      expect(output).to include('cov-loupe')
-    end
-
-    it 'actually runs MCP server mode when no CLI indicators present' do
-      ENV['COV_LOUPE_OPTS'] = ''
-
-      # Mock STDIN to not be a TTY and to provide valid JSON-RPC
-      allow($stdin).to receive(:tty?).and_return(false)
-
-      # Provide a minimal JSON-RPC request that the server can handle
-      json_request = JSON.generate({
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'initialize',
-        params: {
-          protocolVersion: '2024-11-05',
-          capabilities: {},
-          clientInfo: { name: 'test', version: '1.0' }
-        }
-      })
-
-      allow($stdin).to receive(:gets).and_return(json_request, nil)
-
-      # Capture output to verify MCP server response
-      output = nil
-      silence_output do |out, err|
-        CovLoupe.run([])
-        output = out.string + err.string
-      end
-
-      # Verify MCP server ran by checking for JSON-RPC response
-      expect(output).to include('"jsonrpc"')
-      expect(output).to include('"result"')
-    end
-  end
-
-  describe 'integration with actual CLI usage' do
-    it 'works end-to-end with --resultset option' do
-      test_resultset = File.join(Dir.tmpdir, 'test_coverage', '.resultset.json')
-      ENV['COV_LOUPE_OPTS'] = "--resultset #{test_resultset} --format json"
-      env_opts = CovLoupe.send(:extract_env_opts)
-
-      swallow_system_exit do
-        silence_output { cli.send(:run, env_opts + ['--help']) }
-      end
-
-      expect(cli.config.resultset).to eq(test_resultset)
-      expect(cli.config.format).to eq(:json)
-    end
-  end
-end

data/spec/coverage_reporter_spec.rb

@@ -1,102 +0,0 @@
-# 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

@@ -1,59 +0,0 @@
-# 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

@@ -1,37 +0,0 @@
-# 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

@@ -1,197 +0,0 @@
-# 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