cov-loupe 3.0.0

data/spec/cli_error_spec.rb

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

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

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

data/spec/cli_source_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CovLoupe::CoverageCLI do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+
+  it 'renders uncovered source without error for fixture file' do
+    out, err, status = run_cli_with_status(
+      '--root', root, '--resultset', 'coverage', '--source', 'uncovered', '--context-lines', '1',
+      '--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 full source for uncovered command without brittle spacing' do
+    out, err, status = run_cli_with_status(
+      '--root', root, '--resultset', 'coverage', '--source', 'full', '--no-color',
+      'uncovered', 'lib/foo.rb'
+    )
+    expect(status).to eq(0)
+    expect(err).to eq('')
+    expect(out).to include('│')  # Table format
+    expect(out).to include('66.67%')
+    expect(out).to show_source_table_or_fallback
+  end
+
+  it 'renders source for summary with uncovered mode without crashing' do
+    out, err, status = run_cli_with_status(
+      '--root', root, '--resultset', 'coverage', '--source', 'uncovered', '--context-lines', '1',
+      '--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('│')  # Table format
+    expect(out).to show_source_table_or_fallback
+  end
+end

data/spec/cli_spec.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tempfile'
+
+RSpec.describe CovLoupe::CoverageCLI do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+
+  def run_cli(*argv)
+    cli = described_class.new
+    silence_output do |out, _err|
+      begin
+        cli.run(argv.flatten)
+      rescue SystemExit
+        # Ignore exit, just capture output
+      end
+      return out.string
+    end
+  end
+
+  describe 'JSON output' do
+    def with_json_output(command, *args)
+      output = run_cli('--format', 'json', '--root', root, '--resultset', 'coverage',
+        command, *args)
+      yield JSON.parse(output)
+    end
+
+    it 'prints summary as JSON' do
+      with_json_output('summary', 'lib/foo.rb') do |data|
+        expect(data['summary']).to include('covered' => 2)
+      end
+    end
+
+    it 'prints raw as JSON' do
+      with_json_output('raw', 'lib/foo.rb') do |data|
+        expect(data['lines']).to eq([1, 0, nil, 2])
+      end
+    end
+
+    it 'prints uncovered as JSON' do
+      with_json_output('uncovered', 'lib/foo.rb') do |data|
+        expect(data['uncovered']).to eq([2])
+      end
+    end
+
+    it 'prints detailed as JSON' do
+      with_json_output('detailed', 'lib/foo.rb') do |data|
+        expect(data['lines']).to be_an(Array)
+      end
+    end
+
+    it 'prints totals as JSON' do
+      with_json_output('totals') do |data|
+        expect(data['lines']).to include('total' => 6, 'covered' => 3, 'uncovered' => 3)
+        expect(data['files']).to include('total' => 2)
+        expect(data['files']['ok'] + data['files']['stale']).to eq(data['files']['total'])
+      end
+    end
+  end
+
+  it 'prints raw lines as text' do
+    output = run_cli('--root', root, '--resultset', 'coverage', 'raw', 'lib/foo.rb')
+    expect(output).to include('File: lib/foo.rb')
+    expect(output).to include('│')  # Table format
+  end
+
+  it 'list subcommand with --json outputs JSON with sort order' do
+    output = run_cli(
+      '--format', 'json', '--root', root, '--resultset', 'coverage', '--sort-order', 'a', 'list'
+    )
+    asc = JSON.parse(output)
+    expect(asc['files']).to be_an(Array)
+    expect(asc['files'].first['file']).to end_with('lib/bar.rb')
+
+    # Includes counts for total/ok/stale and they are consistent
+    expect(asc['counts']).to include('total', 'ok', 'stale')
+    total = asc['counts']['total']
+    ok = asc['counts']['ok']
+    stale = asc['counts']['stale']
+    expect(total).to eq(asc['files'].length)
+    expect(ok + stale).to eq(total)
+
+    output = run_cli(
+      '--format', 'json', '--root', root, '--resultset', 'coverage', '--sort-order', 'd', 'list'
+    )
+    desc = JSON.parse(output)
+    expect(desc['files'].first['file']).to end_with('lib/foo.rb')
+  end
+
+  it 'list subcommand outputs formatted table' do
+    output = run_cli('--root', root, '--resultset', 'coverage', 'list')
+    expect(output).to include('File')
+    expect(output).to include('lib/foo.rb')
+    expect(output).to include('lib/bar.rb')
+    expect(output).to match(/Files: total \d+/)
+  end
+
+  it 'list subcommand retains rows when using an absolute tracked glob' do
+    absolute_glob = File.join(root, 'lib', '**', '*.rb')
+    output = run_cli('--root', root, '--resultset', 'coverage', '--tracked-globs',
+      absolute_glob, 'list')
+    expect(output).not_to include('No coverage data found')
+    expect(output).to include('lib/foo.rb')
+    expect(output).to include('lib/bar.rb')
+  end
+
+  it 'totals subcommand prints a readable summary by default' do
+    output = run_cli('--root', root, '--resultset', 'coverage', 'totals')
+    expect(output).to include('│')  # Table format
+    expect(output).to include('Lines')
+    # expect(output).to include('Average coverage:')  # Not in table version
+  end
+
+  it 'can include source in JSON payload (nil if file missing)' do
+    output = run_cli('--format', 'json', '--root', root, '--resultset', 'coverage',
+      '--source', 'full', 'summary', 'lib/foo.rb')
+    data = JSON.parse(output)
+    expect(data).to have_key('source')
+  end
+
+  describe 'log file configuration' do
+    it 'passes --log-file path into the CLI execution context' do
+      Dir.mktmpdir do |dir|
+        log_path = File.join(dir, 'custom.log')
+        expect(CovLoupe).to receive(:create_context)
+          .and_wrap_original do |m, error_handler:, log_target:, mode:|
+          # Ensure CLI forwards the requested log path into the context without changing other fields.
+          expect(log_target).to eq(log_path)
+          m.call(error_handler: error_handler, log_target: log_target, mode: mode)
+        end
+        original_target = CovLoupe.active_log_file
+        run_cli('--format', 'json', '--root', root, '--resultset', 'coverage',
+          '--log-file', log_path, 'summary', 'lib/foo.rb')
+        expect(CovLoupe.active_log_file).to eq(original_target)
+      end
+    end
+
+    it 'supports stdout logging within the CLI context' do
+      expect(CovLoupe).to receive(:create_context)
+        .and_wrap_original do |m, error_handler:, log_target:, mode:|
+        # For stdout logging, verify the context is still constructed with the expected value.
+        expect(log_target).to eq('stdout')
+        m.call(error_handler: error_handler, log_target: log_target, mode: mode)
+      end
+      original_target = CovLoupe.active_log_file
+      run_cli('--format', 'json', '--root', root, '--resultset', 'coverage',
+        '--log-file', 'stdout', 'summary', 'lib/foo.rb')
+      expect(CovLoupe.active_log_file).to eq(original_target)
+    end
+  end
+
+
+
+
+
+  describe 'version command' do
+    it 'prints version as plain text by default' do
+      output = run_cli('version')
+      expect(output).to include('│')  # Table format
+      expect(output).to include(CovLoupe::VERSION)
+      expect(output).not_to include('{')
+      expect(output).not_to include('}')
+    end
+
+    it 'prints version as JSON when --json flag is used' do
+      output = run_cli('--format', 'json', 'version')
+      data = JSON.parse(output)
+      expect(data).to have_key('version')
+      expect(data['version']).to eq(CovLoupe::VERSION)
+    end
+
+    it 'works with version command and other flags' do
+      output = run_cli('--root', root, 'version')
+      expect(output).to include('│')  # Table format
+      expect(output).to include(CovLoupe::VERSION)
+    end
+  end
+
+  describe 'version option (-v)' do
+    it 'prints the same version info as the version subcommand' do
+      output = run_cli('-v')
+      expect(output).to include('│')  # Table format
+      expect(output).to include(CovLoupe::VERSION)
+    end
+
+    it 'respects --json when -v is used' do
+      output = run_cli('-v', '--format', 'json')
+      data = JSON.parse(output)
+      expect(data['version']).to eq(CovLoupe::VERSION)
+    end
+  end
+end

data/spec/cli_table_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CovLoupe::CoverageCLI do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+
+  def run_cli(*argv)
+    cli = described_class.new
+    silence_output do |out, _err|
+      cli.run(argv.flatten)
+      return out.string
+    end
+  end
+
+  it 'prints default table when no subcommand is given' do
+    output = run_cli('--root', root, '--resultset', 'coverage')
+
+    # Contains a header row and at least one data row with expected columns
+    expect(output).to include('File')
+    expect(output).to include('Covered')
+    expect(output).to include('Total')
+
+    # Should list fixture files from the demo project
+    expect(output).to include('lib/foo.rb')
+    expect(output).to include('lib/bar.rb')
+  end
+end

data/spec/cli_usage_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tempfile'
+
+RSpec.describe CovLoupe::CoverageCLI do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+
+  it 'errors with usage when summary path is missing' do
+    _out, err, status = run_cli_with_status('--root', root, '--resultset', 'coverage', 'summary')
+    expect(status).to eq(1)
+    expect(err).to include('Usage: cov-loupe summary <path>')
+  end
+
+  it 'errors with meaningful message for unknown subcommand' do
+    _out, err, status = run_cli_with_status('--root', root, '--resultset', 'coverage', 'bogus')
+    expect(status).to eq(1)
+    expect(err).to include("Unknown subcommand: 'bogus'", 'Valid subcommands:')
+  end
+
+  it 'list honors stale=error and tracked_globs by exiting 1 when project is stale' do
+    Tempfile.create(['brand_new_file_for_cli_usage_spec', '.rb'], File.join(root, 'lib')) do |f|
+      f.write("# new file\n")
+      f.flush
+      _out, err, status = run_cli_with_status(
+        '--root', root, '--resultset', 'coverage', '--staleness', 'error', '--tracked-globs',
+        'lib/**/*.rb', 'list'
+      )
+      expect(status).to eq(1)
+      expect(err).to include('Coverage data stale (project)')
+    end
+  end
+
+  it 'list with stale=off prints table and exits 0' do
+    out, err, status = run_cli_with_status(
+      '--root', root, '--resultset', 'coverage', '--staleness', 'off', 'list'
+    )
+    expect(status).to eq(0)
+    expect(err).to eq('')
+    expect(out).to include('File', 'lib/foo.rb')
+  end
+end