cov-loupe 3.0.0 → 4.0.0.pre

data/spec/app_config_spec.rb

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe CovLoupe::AppConfig do
-  describe '#initialize' do
-    it 'creates a config with default values' do
-      config = described_class.new
-      expect(config.root).to eq('.')
-      expect(config.format).to eq(:table)
-      expect(config.sort_order).to eq(:descending)
-      expect(config.source_context).to eq(2)
-      expect(config.error_mode).to eq(:log)
-      expect(config.staleness).to eq(:off)
-      expect(config.resultset).to be_nil
-      expect(config.source_mode).to be_nil
-      expect(config.tracked_globs).to be_nil
-      expect(config.log_file).to be_nil
-    end
-
-    it 'allows overriding defaults via keyword arguments' do
-      config = described_class.new(
-        root: '/custom',
-        format: :json,
-        sort_order: :descending,
-        staleness: :error
-      )
-      expect(config.root).to eq('/custom')
-      expect(config.format).to eq(:json)
-      expect(config.sort_order).to eq(:descending)
-      expect(config.staleness).to eq(:error)
-    end
-
-    it 'is mutable (struct fields can be changed)' do
-      config = described_class.new
-      config.root = '/new/root'
-      config.format = :json
-      expect(config.root).to eq('/new/root')
-      expect(config.format).to eq(:json)
-    end
-  end
-
-  describe '#model_options' do
-    it 'returns hash suitable for CoverageModel.new' do
-      config = described_class.new(
-        root: '/custom/root',
-        resultset: '/custom/.resultset.json',
-        staleness: :error,
-        tracked_globs: ['lib/**/*.rb']
-      )
-
-      options = config.model_options
-      expect(options).to eq({
-        root: '/custom/root',
-        resultset: '/custom/.resultset.json',
-        staleness: :error,
-        tracked_globs: ['lib/**/*.rb']
-      })
-    end
-
-    it 'handles nil values correctly' do
-      config = described_class.new
-      options = config.model_options
-      expect(options[:root]).to eq('.')
-      expect(options[:resultset]).to be_nil
-      expect(options[:staleness]).to eq(:off)
-      expect(options[:tracked_globs]).to be_nil
-    end
-  end
-
-  describe '#formatter_options' do
-    it 'returns hash suitable for SourceFormatter.new' do
-      config = described_class.new(color: true)
-      options = config.formatter_options
-      expect(options).to eq({ color_enabled: true })
-    end
-
-    it 'handles false color setting' do
-      config = described_class.new(color: false)
-      options = config.formatter_options
-      expect(options).to eq({ color_enabled: false })
-    end
-  end
-
-  describe 'struct behavior' do
-    it 'supports equality comparison' do
-      config1 = described_class.new(root: '/foo', format: :json)
-      config2 = described_class.new(root: '/foo', format: :json)
-      config3 = described_class.new(root: '/bar', format: :json)
-
-      expect(config1).to eq(config2)
-      expect(config1).not_to eq(config3)
-    end
-
-    it 'provides readable inspect output' do
-      config = described_class.new(root: '/test', format: :json)
-      output = config.inspect
-      expect(output).to include('root="/test"')
-      expect(output).to include('format=:json')
-    end
-
-    it 'converts to hash' do
-      config = described_class.new(root: '/test', format: :json)
-      hash = config.to_h
-      expect(hash).to be_a(Hash)
-      expect(hash[:root]).to eq('/test')
-      expect(hash[:format]).to eq(:json)
-    end
-  end
-
-  describe 'symbol enumerated values' do
-    it 'uses symbols for format' do
-      config = described_class.new(format: :json)
-      expect(config.format).to eq(:json)
-      expect(config.format).to be_a(Symbol)
-    end
-
-    it 'uses symbols for sort_order' do
-      config = described_class.new(sort_order: :descending)
-      expect(config.sort_order).to eq(:descending)
-      expect(config.sort_order).to be_a(Symbol)
-    end
-
-    it 'uses symbols for staleness' do
-      config = described_class.new(staleness: :error)
-      expect(config.staleness).to eq(:error)
-      expect(config.staleness).to be_a(Symbol)
-    end
-
-    it 'uses symbols for error_mode' do
-      config = described_class.new(error_mode: :debug)
-      expect(config.error_mode).to eq(:debug)
-      expect(config.error_mode).to be_a(Symbol)
-    end
-
-    it 'uses symbols for source_mode' do
-      config = described_class.new(source_mode: :uncovered)
-      expect(config.source_mode).to eq(:uncovered)
-      expect(config.source_mode).to be_a(Symbol)
-    end
-  end
-end

data/spec/base_tool_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe CovLoupe::BaseTool do
-  let(:handler) { CovLoupe::ErrorHandler.new(error_mode: :log, logger: test_logger) }
-  let(:test_logger) do
-    Class.new do
-      attr_reader :messages
-
-      def initialize = @messages = []
-      def error(msg) = @messages << msg
-    end.new
-  end
-
-  let(:orig_handler) do
-    CovLoupe.error_handler
-  rescue
-    nil
-  end
-
-  before do
-    CovLoupe.error_handler = handler
-    setup_mcp_response_stub
-  end
-
-  after do
-    CovLoupe.error_handler = orig_handler if orig_handler
-  end
-
-  shared_examples 'friendly response and logged' do
-    it 'returns friendly text' do
-      resp = described_class.handle_mcp_error(error, tool, error_mode: :log)
-      expect(resp).to be_a(MCP::Tool::Response)
-      expect(resp.payload.first['text']).to match(expected_pattern)
-    end
-
-    it 'respects error_mode :off' do
-      resp = described_class.handle_mcp_error(error, tool, error_mode: :off)
-      expect(resp).to be_a(MCP::Tool::Response)
-      expect(resp.payload.first['text']).to match(expected_pattern)
-    end
-  end
-
-  context 'with CovLoupe::Error' do
-    let(:error) { CovLoupe::UsageError.new('invalid args') }
-    let(:tool) { 'coverage_summary' }
-    let(:expected_pattern) { /Error: invalid args/ }
-    let(:log_fragment) { 'invalid args' }
-
-    it_behaves_like 'friendly response and logged'
-  end
-
-  context 'with standard error' do
-    let(:error) { Errno::ENOENT.new('No such file or directory @ rb_sysopen - missing.rb') }
-    let(:tool) { 'coverage_raw' }
-    let(:expected_pattern) { /Error: .*File not found: missing.rb/ }
-    let(:log_fragment) { 'File not found' }
-
-    it_behaves_like 'friendly response and logged'
-  end
-end

data/spec/cli/show_default_report_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe CovLoupe::CoverageCLI do
-  let(:root) { (FIXTURES_DIR / 'project1').to_s }
-  let(:cli) { described_class.new }
-
-  before do
-    cli.config.root = root
-    cli.config.resultset = 'coverage'
-    cli.config.staleness = :off
-    cli.config.tracked_globs = nil
-  end
-
-  describe '#show_default_report' do
-    it 'prints JSON summary using relativized payload when json mode is enabled' do
-      cli.config.format = :json
-
-      output = nil
-      silence_output do |stdout, _stderr|
-        cli.show_default_report(sort_order: :ascending, output: stdout)
-        output = stdout.string
-      end
-
-      payload = JSON.parse(output)
-
-      expect(payload['files']).to be_an(Array)
-      expect(payload['files'].first['file']).to eq('lib/bar.rb').or eq('lib/foo.rb')
-      expect(payload['counts']).to include('total', 'ok', 'stale')
-    end
-  end
-end

data/spec/cli_enumerated_options_spec.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'CLI enumerated option parsing' do
-  def parse!(argv)
-    cli = CovLoupe::CoverageCLI.new
-    cli.send(:parse_options!, argv.dup)
-    cli
-  end
-
-  describe 'accepts short and long forms' do
-    cases = [
-      { argv: ['--sort-order', 'a', 'list'], accessor: :sort_order, expected: :ascending },
-      { argv: ['--sort-order', 'd', 'list'], accessor: :sort_order, expected: :descending },
-      { argv: ['--sort-order', 'ascending', 'list'], accessor: :sort_order, expected: :ascending },
-      { argv: ['--sort-order', 'descending', 'list'], accessor: :sort_order,
-        expected: :descending },
-
-      { argv: ['--source', 'f', 'summary', 'lib/foo.rb'], accessor: :source_mode, expected: :full },
-      { argv: ['--source', 'u', 'summary', 'lib/foo.rb'], accessor: :source_mode,
-        expected: :uncovered },
-      { argv: ['--source', 'full', 'summary', 'lib/foo.rb'], accessor: :source_mode,
-        expected: :full },
-      { argv: ['--source', 'uncovered', 'summary', 'lib/foo.rb'], accessor: :source_mode,
-        expected: :uncovered },
-
-      { argv: ['-S', 'e', 'list'], accessor: :staleness, expected: :error },
-      { argv: ['-S', 'o', 'list'], accessor: :staleness, expected: :off },
-      { argv: ['--staleness', 'e', 'list'], accessor: :staleness, expected: :error },
-      { argv: ['--staleness', 'o', 'list'], accessor: :staleness, expected: :off },
-
-      { argv: ['--error-mode', 'off', 'list'], accessor: :error_mode, expected: :off },
-      { argv: ['--error-mode', 'o', 'list'], accessor: :error_mode, expected: :off },
-      { argv: ['--error-mode', 'log', 'list'], accessor: :error_mode, expected: :log },
-      { argv: ['--error-mode', 'debug', 'list'], accessor: :error_mode, expected: :debug }
-    ]
-
-    cases.each do |c|
-      it "parses #{c[:argv].join(' ')}" do
-        cli = parse!(c[:argv])
-        expect(cli.config.public_send(c[:accessor])).to eq(c[:expected])
-      end
-    end
-  end
-
-  describe 'rejects invalid values' do
-    invalid_cases = [
-      { argv: ['--sort-order', 'asc', 'list'] },
-      { argv: ['--source', 'x', 'summary', 'lib/foo.rb'] },
-      { argv: ['-S', 'x', 'list'] },
-      { argv: ['--staleness', 'x', 'list'] },
-      { argv: ['--error-mode', 'bad', 'list'] },
-      { argv: ['--error-mode', 'on', 'list'] },
-      { argv: ['--error-mode', 'trace', 'list'] }
-    ]
-
-    invalid_cases.each do |c|
-      it "exits 1 for #{c[:argv].join(' ')}" do
-        _out, err, status = run_cli_with_status(*c[:argv])
-        expect(status).to eq(1)
-        expect(err).to include('Error:')
-        expect(err).to include('invalid argument')
-      end
-    end
-  end
-
-  describe 'missing value hints' do
-    it 'exits 1 when -S is provided without a value' do
-      _out, err, status = run_cli_with_status('-S', 'list')
-      expect(status).to eq(1)
-      expect(err).to include('invalid argument')
-    end
-
-    it 'exits 1 when --staleness is provided without a value' do
-      _out, err, status = run_cli_with_status('--staleness', 'list')
-      expect(status).to eq(1)
-      expect(err).to include('invalid argument')
-    end
-
-    it 'exits 1 when --source is provided without a value' do
-      _out, err, status = run_cli_with_status('--source', 'summary', 'lib/foo.rb')
-      expect(status).to eq(1)
-      # Depending on OptParse implementation for required argument, it might say "missing argument"
-      # But usually it consumes next arg. If 'summary' is consumed as argument for source:
-      # normalize_source_mode('summary') -> raises InvalidArgument.
-      expect(err).to include('invalid argument')
-    end
-  end
-end

data/spec/cli_error_spec.rb

@@ -1,184 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe CovLoupe::CoverageCLI do
-  let(:root) { (FIXTURES_DIR / 'project1').to_s }
-
-  it 'shows help and exits 0' do
-    out, err, status = run_cli_with_status('--help')
-    expect(status).to eq(0)
-    expect(out).to match(/Usage:.*cov-loupe/)
-    expect(out).to include(
-      'Repository: https://github.com/keithrbennett/cov-loupe',
-      'Subcommands:'
-    )
-    expect(out).to match(/Version:.*#{CovLoupe::VERSION}/)
-    expect(err).to eq('')
-  end
-
-  shared_examples 'maps error to exit 1 with message' do
-    before do
-      # Build a fake model that raises the specified error from the specified method
-      fake_model = Class.new do
-        def initialize(*)
-        end
-      end
-      error_to_raise = raised_error
-      fake_model.define_method(model_method) { |*| raise error_to_raise }
-      stub_const('CovLoupe::CoverageModel', fake_model)
-    end
-
-    it 'exits with status 1 and friendly message' do
-      _out, err, status = run_cli_with_status(*invoke_args)
-      expect(status).to eq(1)
-      expect(err).to include(expected_message)
-    end
-  end
-
-  context 'when mapping ENOENT' do
-    let(:model_method) { :summary_for }
-    let(:raised_error) { Errno::ENOENT.new('No such file or directory @ rb_sysopen - missing.rb') }
-    let(:invoke_args) { ['--root', root, '--resultset', 'coverage', 'summary', 'lib/missing.rb'] }
-    let(:expected_message) { 'File error: File not found: lib/missing.rb' }
-
-    it_behaves_like 'maps error to exit 1 with message'
-  end
-
-  context 'when mapping EACCES' do
-    let(:model_method) { :raw_for }
-    let(:raised_error) { Errno::EACCES.new('Permission denied @ rb_sysopen - secret.rb') }
-    let(:invoke_args) { ['--root', root, '--resultset', 'coverage', 'raw', 'lib/secret.rb'] }
-    let(:expected_message) { 'Permission denied: lib/secret.rb' }
-
-    it_behaves_like 'maps error to exit 1 with message'
-  end
-
-  it 'emits detailed stale coverage info and exits 1' do
-    mock_resultset_with_timestamp(root, VERY_OLD_TIMESTAMP, coverage: {
-      File.join(root, 'lib', 'foo.rb') => { 'lines' => [1, 0, 1] }
-    })
-
-    _out, err, status = run_cli_with_status('--root', root, '--resultset', 'coverage',
-      '--staleness', 'error', 'summary', 'lib/foo.rb')
-    expect(status).to eq(1)
-    expect(err).to include('Coverage data stale:')
-    expect(err).to match(/File\s+- time:/)
-    expect(err).to match('Coverage\s+- time:')
-    expect(err).to match(/Delta\s+- file is [+-]?\d+s newer than coverage/)
-    expect(err).to match('Resultset\s+-')
-  end
-
-  it 'honors --no-strict-staleness to disable checks' do
-    mock_resultset_with_timestamp(root, VERY_OLD_TIMESTAMP, coverage: {
-      File.join(root, 'lib', 'foo.rb') => { 'lines' => [1, 0, 1] }
-    })
-
-    _out, err, status = run_cli_with_status('--root', root, '--resultset', 'coverage',
-      '--staleness', 'off', 'summary', 'lib/foo.rb')
-    expect(status).to eq(0)
-    expect(err).to eq('')
-  end
-
-  it 'handles source rendering errors gracefully with fallback message' do
-    # Test that source rendering with problematic coverage data doesn't crash
-    # This is a regression test for the "can't convert nil into Integer" crash
-    # that was previously mentioned in comments
-    out, err, status = run_cli_with_status(
-      '--root', root, '--resultset', 'coverage', '--source', 'uncovered', '--context-lines', '2',
-      '--no-color', 'uncovered', 'lib/foo.rb'
-    )
-
-    expect(status).to eq(0)
-    expect(err).to eq('')
-    expect(out).to match(/File:\s+lib\/foo\.rb/)
-    expect(out).to include('│')  # Table format
-    expect(out).to show_source_table_or_fallback
-  end
-
-  it 'renders source with full mode without crashing' do
-    # Additional regression test for source rendering with full mode
-    out, err, status = run_cli_with_status(
-      '--root', root, '--resultset', 'coverage', '--source', 'full', '--no-color',
-      'summary', 'lib/foo.rb'
-    )
-
-    expect(status).to eq(0)
-    expect(err).to eq('')
-    expect(out).to include('lib/foo.rb')
-    expect(out).to include('66.67%')
-    expect(out).to show_source_table_or_fallback
-  end
-
-  it 'shows fallback message when source file is unreadable' do
-    # Test the fallback path when source files can't be read
-    # Temporarily rename the source file to make it unreadable
-    foo_path = File.join(root, 'lib', 'foo.rb')
-    temp_path = "#{foo_path}.hidden"
-
-    begin
-      File.rename(foo_path, temp_path) if File.exist?(foo_path)
-
-      out, err, status = run_cli_with_status(
-        '--root', root, '--resultset', 'coverage', '--source', 'full', '--no-color',
-        'summary', 'lib/foo.rb'
-      )
-
-      expect(status).to eq(0)
-      expect(err).to eq('')
-      expect(out).to include('lib/foo.rb')
-      expect(out).to include('66.67%')
-      expect(out).to include('[source not available]')
-    ensure
-      # Restore the file
-      File.rename(temp_path, foo_path) if File.exist?(temp_path)
-    end
-  end
-
-  describe 'invalid option handling' do
-    it 'suggests subcommand for --subcommand-like option' do
-      _out, err, status = run_cli_with_status('--summary')
-      expect(status).to eq(1)
-      expect(err).to include(
-        "Error: '--summary' is not a valid option. Did you mean the 'summary' subcommand?"
-      )
-      expect(err).to include('Try: cov-loupe summary [args]')
-    end
-
-    it 'reports invalid enum value for --opt=value' do
-      _out, err, status = run_cli_with_status('--staleness=bogus', 'list')
-      expect(status).to eq(1)
-      expect(err).to include('invalid argument: --staleness=bogus')
-    end
-
-    it 'reports invalid enum value for --opt value' do
-      _out, err, status = run_cli_with_status('--staleness', 'bogus', 'list')
-      expect(status).to eq(1)
-      expect(err).to include('invalid argument: bogus')
-    end
-
-    it 'handles generic invalid options' do
-      _out, err, status = run_cli_with_status('--no-such-option')
-      expect(status).to eq(1)
-      expect(err).to include('Error: invalid option: --no-such-option')
-    end
-  end
-
-  describe 'subcommand error handling' do
-    it 'handles generic exceptions from subcommands' do
-      # Stub the CommandFactory to return a command that raises a StandardError
-      fake_command = Class.new do
-        def initialize(_cli) = nil
-        def execute(_args) = raise(StandardError, 'Unexpected error in subcommand')
-      end
-
-      allow(CovLoupe::Commands::CommandFactory).to receive(:create)
-        .and_return(fake_command.new(nil))
-
-      _out, err, status = run_cli_with_status('--root', root, '--resultset', 'coverage', 'summary',
-        'lib/foo.rb')
-      expect(status).to eq(1)
-      expect(err).to include('Unexpected error in subcommand')
-    end
-  end
-end

data/spec/cli_format_spec.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe CovLoupe::CoverageCLI, 'format option' 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 'format normalization' do
-    it 'normalizes short format aliases' do
-      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'j', 'list')
-      expect(output).to include('"files":', '"percentage":')
-      data = JSON.parse(output)
-      expect(data['files']).to be_an(Array)
-    end
-
-    it 'normalizes table format' do
-      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 't', 'list')
-      expect(output).to include('File', '%')  # Table output
-      expect(output).not_to include('"files"')  # Not JSON
-    end
-
-    it 'supports yaml format' do
-      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'y', 'list')
-      expect(output).to include('---', 'files:', 'file:')
-    end
-
-    it 'supports awesome_print format' do
-      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'a', 'list')
-      # AwesomePrint output contains colored/formatted structure
-      expect(output).to match(/:files|"files"/)
-    end
-  end
-
-  describe 'option order requirements' do
-    it 'works with format option before subcommand' do
-      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'json', 'list')
-      data = JSON.parse(output)
-      expect(data).to have_key('files')
-    end
-
-    it 'shows helpful error when global option comes after subcommand' do
-      _out, err, status = run_cli_with_status(
-        '--root', root, '--resultset', 'coverage', 'list', '--format', 'json'
-      )
-      expect(status).to eq(1)
-      expect(err).to include(
-        'Global option(s) must come BEFORE the subcommand',
-        'You used: list --format',
-        'Correct: --format list',
-        'Example:'
-      )
-    end
-  end
-
-  describe 'format with different subcommands' do
-    it 'works with totals subcommand' do
-      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'json', 'totals')
-      data = JSON.parse(output)
-      expect(data).to have_key('lines')
-      expect(data).to have_key('percentage')
-    end
-
-    it 'works with summary subcommand' do
-      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'json',
-        'summary', 'lib/foo.rb')
-      data = JSON.parse(output)
-      expect(data).to have_key('file')
-      expect(data).to have_key('summary')
-    end
-
-    it 'works with version subcommand' do
-      output = run_cli('--format', 'json', 'version')
-      data = JSON.parse(output)
-      expect(data).to have_key('version')
-      expect(data).to have_key('gem_root')
-    end
-  end
-
-  describe 'comprehensive misplaced option detection' do
-    # Array of test cases: [description, args_array, expected_option_in_error]
-    [
-      # Short-form options
-      ['short -f after list', ['list', '-f', 'json'], '-f'],
-      ['short -r after totals', ['totals', '-r', '.resultset.json'], '-r'],
-      ['short -R after list', ['list', '-R', '/tmp'], '-R'],
-      ['short -o after list', ['list', '-o', 'a'], '-o'],
-      ['short -s after list', ['list', '-s', 'full'], '-s'],
-      ['short -S after list', ['list', '-S', 'error'], '-S'],
-
-      # Long-form options
-      ['--sort-order after list', ['list', '--sort-order', 'ascending'], '--sort-order'],
-      ['--source after list', ['list', '--source', 'full'], '--source'],
-      ['--staleness after totals', ['totals', '--staleness', 'error'], '--staleness'],
-      ['--color after list', ['list', '--color'], '--color'],
-      ['--no-color after list', ['list', '--no-color'], '--no-color'],
-      ['--log-file after list', ['list', '--log-file', '/tmp/test.log'], '--log-file'],
-
-      # Different subcommands
-      ['option after version', ['version', '--format', 'json'], '--format'],
-      ['option after summary', ['summary', 'lib/foo.rb', '--format', 'json'], '--format'],
-      ['option after raw', ['raw', 'lib/foo.rb', '-f', 'json'], '-f'],
-      ['option after detailed', ['detailed', 'lib/foo.rb', '-f', 'json'], '-f'],
-      ['option after uncovered', ['uncovered', 'lib/foo.rb', '--root', '/tmp'], '--root']
-    ].each do |desc, args, option|
-      it "detects #{desc}" do
-        _out, err, status = run_cli_with_status(*args)
-        expect(status).to eq(1)
-        expect(err).to include('Global option(s) must come BEFORE the subcommand')
-        expect(err).to include(option)
-      end
-    end
-  end
-end

data/spec/cli_json_options_spec.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe CovLoupe::CoverageCLI, 'json format options' do
-  let(:root) { (FIXTURES_DIR / 'project1').to_s }
-
-  def run_cli_output(*argv)
-    cli = CovLoupe::CoverageCLI.new
-    output = nil
-    silence_output do |stdout, _stderr|
-      cli.send(:run, argv)
-      output = stdout.string
-    end
-    output
-  end
-
-  describe 'JSON format options' do
-    it 'produces compact JSON with -f j' do
-      output = run_cli_output('--root', root, '--resultset', 'coverage', '-f', 'j', 'list')
-
-      expect(output.strip.lines.count).to eq(1)
-      data = JSON.parse(output)
-      expect(data['files']).to be_an(Array)
-    end
-
-    it 'produces pretty JSON with -f pretty-json' do
-      output = run_cli_output('--root', root, '--resultset', 'coverage', '-f', 'pretty-json',
-        'list')
-      expect(output.strip.lines.count).to be > 1
-      data = JSON.parse(output)
-      expect(data['files']).to be_an(Array)
-    end
-
-    it 'produces pretty JSON with -f pretty_json (underscore variant)' do
-      output = run_cli_output('--root', root, '--resultset', 'coverage', '-f', 'pretty_json',
-        'list')
-      expect(output.strip.lines.count).to be > 1
-      data = JSON.parse(output)
-      expect(data['files']).to be_an(Array)
-    end
-
-    it 'produces compact JSON with -f json' do
-      output = run_cli_output('--root', root, '--resultset', 'coverage', '-f', 'json', 'list')
-      expect(output.strip.lines.count).to eq(1)
-      data = JSON.parse(output)
-      expect(data['files']).to be_an(Array)
-    end
-  end
-end