cov-loupe 3.0.0

data/spec/commands/base_command_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CovLoupe::Commands::BaseCommand do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:cli_context) { CovLoupe::CoverageCLI.new }
+
+  # Create a test command class that exposes protected methods for testing
+  let(:test_command_class) do
+    Class.new(CovLoupe::Commands::BaseCommand) do
+      def execute(args)
+        # Not needed for these tests
+      end
+
+      # Expose protected methods for testing
+      def public_handle_with_path(args, name, &)
+        handle_with_path(args, name, &)
+      end
+    end
+  end
+
+  let(:test_command) { test_command_class.new(cli_context) }
+
+  describe '#handle_with_path' do
+    context 'when Errno::ENOENT is raised' do
+      it 'converts to FileNotFoundError with correct message' do
+        args = ['lib/missing.rb']
+
+        # Stub the block to raise Errno::ENOENT
+        expect do
+          test_command.public_handle_with_path(args, 'test') do |_path|
+            raise Errno::ENOENT, 'No such file or directory'
+          end
+        end.to raise_error(CovLoupe::FileNotFoundError, 'File not found: lib/missing.rb')
+      end
+
+      it 'includes the path from the args in the error message' do
+        args = ['some/other/path.rb']
+
+        expect do
+          test_command.public_handle_with_path(args, 'test') do |_path|
+            raise Errno::ENOENT, 'No such file or directory'
+          end
+        end.to raise_error(CovLoupe::FileNotFoundError, /some\/other\/path\.rb/)
+      end
+    end
+
+    context 'when Errno::EACCES is raised' do
+      it 'converts to FilePermissionError with correct message' do
+        args = ['lib/secret.rb']
+
+        # Stub the block to raise Errno::EACCES
+        expect do
+          test_command.public_handle_with_path(args, 'test') do |_path|
+            raise Errno::EACCES, 'Permission denied'
+          end
+        end.to raise_error(CovLoupe::FilePermissionError, 'Permission denied: lib/secret.rb')
+      end
+
+      it 'includes the path from the args in the error message' do
+        args = ['/root/protected.rb']
+
+        expect do
+          test_command.public_handle_with_path(args, 'test') do |_path|
+            raise Errno::EACCES, 'Permission denied'
+          end
+        end.to raise_error(CovLoupe::FilePermissionError, /\/root\/protected\.rb/)
+      end
+    end
+
+    context 'when no path is provided' do
+      it 'raises UsageError' do
+        args = []
+
+        expect do
+          test_command.public_handle_with_path(args, 'summary') do |_path|
+            # Should not reach here
+          end
+        end.to raise_error(CovLoupe::UsageError, /summary <path>/)
+      end
+    end
+
+    context 'when successful' do
+      it 'yields the path to the block' do
+        args = ['lib/foo.rb']
+        yielded_path = nil
+
+        test_command.public_handle_with_path(args, 'test') do |path|
+          yielded_path = path
+        end
+
+        expect(yielded_path).to eq('lib/foo.rb')
+      end
+
+      it 'shifts the path from args' do
+        args = ['lib/foo.rb', 'extra', 'args']
+
+        test_command.public_handle_with_path(args, 'test') do |_path|
+          # Block execution
+        end
+
+        expect(args).to eq(['extra', 'args'])
+      end
+    end
+  end
+end

data/spec/commands/command_factory_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CovLoupe::Commands::CommandFactory do
+  let(:cli_context) { CovLoupe::CoverageCLI.new }
+
+  describe '.create' do
+    context 'with valid command names' do
+      [
+        ['list', CovLoupe::Commands::ListCommand],
+        ['version', CovLoupe::Commands::VersionCommand],
+        ['summary', CovLoupe::Commands::SummaryCommand],
+        ['raw', CovLoupe::Commands::RawCommand],
+        ['uncovered', CovLoupe::Commands::UncoveredCommand],
+        ['detailed', CovLoupe::Commands::DetailedCommand],
+        ['totals', CovLoupe::Commands::TotalsCommand],
+        ['total', CovLoupe::Commands::TotalsCommand] # Alias
+      ].each do |command_name, command_class|
+        it "creates a #{command_class.name.split('::').last} for \"#{command_name}\"" do
+          command = described_class.create(command_name, cli_context)
+          expect(command).to be_a(command_class)
+        end
+      end
+    end
+
+    context 'with unknown command name' do
+      [
+        [
+          'invalid_cmd',
+          'invalid command',
+          /list \| summary <path> \| raw <path> \| uncovered <path>/
+        ],
+        [nil,           'nil command',            nil],
+        ['',            'empty string command',   nil],
+        ['sumary',      'misspelled command',     nil]
+      ].each do |command_name, description, pattern|
+        it "raises UsageError for #{description}" do
+          expect do
+            described_class.create(command_name, cli_context)
+          end.to raise_error(CovLoupe::UsageError, pattern)
+        end
+      end
+    end
+  end
+
+  describe '.available_commands' do
+    it 'returns an array of available command names' do
+      commands = described_class.available_commands
+      expect(commands).to be_an(Array)
+      expect(commands).to contain_exactly('list', 'version', 'summary', 'raw', 'uncovered',
+        'detailed', 'totals', 'total', 'validate')
+    end
+
+    it 'returns the keys from COMMAND_MAP' do
+      expect(described_class.available_commands).to eq(described_class::COMMAND_MAP.keys)
+    end
+  end
+
+  describe 'COMMAND_MAP' do
+    it 'is frozen to prevent modifications' do
+      expect(described_class::COMMAND_MAP).to be_frozen
+    end
+
+    it 'maps command names to command classes' do
+      expect(described_class::COMMAND_MAP['list']).to eq(CovLoupe::Commands::ListCommand)
+      expect(described_class::COMMAND_MAP['version']).to eq(CovLoupe::Commands::VersionCommand)
+      expect(described_class::COMMAND_MAP['summary']).to eq(CovLoupe::Commands::SummaryCommand)
+      expect(described_class::COMMAND_MAP['raw']).to eq(CovLoupe::Commands::RawCommand)
+      expect(described_class::COMMAND_MAP['uncovered']).to eq(CovLoupe::Commands::UncoveredCommand)
+      expect(described_class::COMMAND_MAP['detailed']).to eq(CovLoupe::Commands::DetailedCommand)
+      expect(described_class::COMMAND_MAP['totals']).to eq(CovLoupe::Commands::TotalsCommand)
+      expect(described_class::COMMAND_MAP['total']).to eq(CovLoupe::Commands::TotalsCommand)
+    end
+  end
+end

data/spec/commands/detailed_command_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../shared_examples/formatted_command_examples'
+
+RSpec.describe CovLoupe::Commands::DetailedCommand do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:cli_context) { CovLoupe::CoverageCLI.new }
+  let(:command) { described_class.new(cli_context) }
+
+  before do
+    cli_context.config.root = root
+    cli_context.config.resultset = 'coverage'
+    cli_context.config.format = :table
+    cli_context.config.source_mode = nil
+  end
+
+  describe '#execute' do
+    context 'with table format' do
+      it 'prints the detailed coverage table' do
+        output = capture_command_output(command, ['lib/foo.rb'])
+
+        expect(output).to include('File: lib/foo.rb', 'Line', 'Covered')
+      end
+    end
+
+    context 'with stale data' do
+      before { stub_staleness_check('L') }
+
+      it_behaves_like 'a command with formatted output', ['lib/foo.rb'],
+        { 'file' => 'lib/foo.rb', 'lines' => nil, 'summary' => nil, 'stale' => 'L' }
+    end
+  end
+end

data/spec/commands/list_command_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../shared_examples/formatted_command_examples'
+
+RSpec.describe CovLoupe::Commands::ListCommand do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:cli_context) { CovLoupe::CoverageCLI.new }
+  let(:command) { described_class.new(cli_context) }
+
+  before do
+    cli_context.config.root = root
+    cli_context.config.resultset = 'coverage'
+    cli_context.config.format = :table
+  end
+
+  describe '#execute' do
+    context 'with table format' do
+      it 'outputs a formatted table' do
+        output = capture_command_output(command, [])
+
+        expect(output).to include('│', 'lib/foo.rb', 'lib/bar.rb')
+      end
+    end
+
+    it_behaves_like 'a command with formatted output', [], ['files', 'counts']
+  end
+end

data/spec/commands/raw_command_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../shared_examples/formatted_command_examples'
+
+RSpec.describe CovLoupe::Commands::RawCommand do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:cli_context) { CovLoupe::CoverageCLI.new }
+  let(:command) { described_class.new(cli_context) }
+
+  before do
+    cli_context.config.root = root
+    cli_context.config.resultset = 'coverage'
+    cli_context.config.format = :table
+  end
+
+  describe '#execute' do
+    context 'with table format' do
+      it 'prints the raw coverage lines for the requested file' do
+        output = capture_command_output(command, ['lib/foo.rb'])
+
+        expect(output).to include('│', 'lib/foo.rb', 'Line', 'Coverage')
+      end
+    end
+
+    context 'when the file is fully covered' do
+      it 'still prints the raw table' do
+        mock_presenter(
+          CovLoupe::Presenters::CoverageRawPresenter,
+          absolute_payload: {
+            'file' => 'lib/perfect.rb',
+            'lines' => [1, 1, 1],
+            'stale' => false
+          },
+          relative_path: 'lib/perfect.rb'
+        )
+
+        output = capture_command_output(command, ['lib/perfect.rb'])
+
+        expect(output).to include('│', '│    1 │        1 │')
+        expect(output).not_to include('All lines covered!')
+      end
+    end
+
+    context 'with JSON output' do
+      before { cli_context.config.format = :json }
+
+      it 'emits JSON with specific line data' do
+        stub_staleness_check('L') # Needed for stale data
+
+        output = capture_command_output(command, ['lib/foo.rb'])
+
+        payload = JSON.parse(output)
+        expect(payload['file']).to eq('lib/foo.rb')
+        expect(payload['lines']).to be_an(Array)
+        expect(payload['lines'][0]).to eq(1) # specific value
+        expect(payload['lines'][1]).to eq(0) # specific value
+        expect(payload['stale']).to eq('L')
+      end
+    end
+
+    context 'with stale data (other formats)' do
+      before { stub_staleness_check('L') }
+
+      # Use an array for expected_json_keys as we don't need exact value matching for these generic format tests
+      it_behaves_like 'a command with formatted output', ['lib/foo.rb'], ['file', 'lines', 'stale']
+    end
+  end
+end

data/spec/commands/summary_command_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../shared_examples/formatted_command_examples'
+
+RSpec.describe CovLoupe::Commands::SummaryCommand do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:cli_context) { CovLoupe::CoverageCLI.new }
+  let(:command) { described_class.new(cli_context) }
+
+  before do
+    cli_context.config.root = root
+    cli_context.config.resultset = 'coverage'
+    cli_context.config.format = :table
+    cli_context.config.source_mode = nil
+  end
+
+  describe '#execute' do
+    context 'with table format' do
+      it 'prints a coverage summary line with a relative path' do
+        output = capture_command_output(command, ['lib/foo.rb'])
+
+        expect(output).to include('│', '66.67%', 'lib/foo.rb')
+      end
+    end
+
+    context 'with stale data' do
+      before { stub_staleness_check('L') }
+
+      it_behaves_like 'a command with formatted output', ['lib/foo.rb'],
+        { 'file' => 'lib/foo.rb', 'summary' => nil, 'stale' => 'L' }
+    end
+  end
+end

data/spec/commands/totals_command_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../shared_examples/formatted_command_examples'
+
+RSpec.describe CovLoupe::Commands::TotalsCommand do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:cli_context) { CovLoupe::CoverageCLI.new }
+  let(:command) { described_class.new(cli_context) }
+
+  before do
+    cli_context.config.root = root
+    cli_context.config.resultset = 'coverage'
+    cli_context.config.format = :table
+  end
+
+  describe '#execute' do
+    context 'with table format' do
+      it 'prints aggregated totals for the project' do
+        output = capture_command_output(command, [])
+
+        expect(output).to include('│', 'Lines', '50.00%')
+      end
+    end
+
+    it_behaves_like 'a command with formatted output', [], ['lines', 'files', 'percentage']
+
+    it 'raises when unexpected arguments are provided' do
+      expect do
+        command.execute(['extra'])
+      end.to raise_error(CovLoupe::UsageError, include('totals'))
+    end
+  end
+end

data/spec/commands/uncovered_command_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../shared_examples/formatted_command_examples'
+
+RSpec.describe CovLoupe::Commands::UncoveredCommand do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:cli_context) { CovLoupe::CoverageCLI.new }
+  let(:command) { described_class.new(cli_context) }
+
+  before do
+    cli_context.config.root = root
+    cli_context.config.resultset = 'coverage'
+    cli_context.config.format = :table
+    cli_context.config.source_mode = nil
+  end
+
+  describe '#execute' do
+    context 'with table format' do
+      it 'prints uncovered line numbers with the summary' do
+        output = capture_command_output(command, ['lib/bar.rb'])
+
+        expect(output).to include('│', 'lib/bar.rb', '33.33%')
+      end
+    end
+
+    context 'when the file is fully covered' do
+      before do
+        mock_presenter(
+          CovLoupe::Presenters::CoverageUncoveredPresenter,
+          absolute_payload: {
+            'file' => 'lib/perfect.rb',
+            'uncovered' => [],
+            'summary' => { 'covered' => 10, 'total' => 10, 'percentage' => 100.0 }
+          },
+          relative_path: 'lib/perfect.rb'
+        )
+      end
+
+      it 'prints a success message instead of a table' do
+        output = capture_command_output(command, ['lib/perfect.rb'])
+
+        expect(output).to include('All lines covered!', '100.00%')
+        expect(output).not_to include('│')
+      end
+    end
+
+    context 'with stale data' do
+      before { stub_staleness_check('L') }
+
+      it_behaves_like 'a command with formatted output', ['lib/foo.rb'],
+        { 'file' => 'lib/foo.rb', 'uncovered' => [2], 'summary' => nil, 'stale' => 'L' }
+    end
+  end
+end

data/spec/commands/validate_command_spec.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tempfile'
+
+RSpec.describe CovLoupe::Commands::ValidateCommand do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+
+  def with_temp_predicate(content)
+    Tempfile.create(['predicate', '.rb']) do |file|
+      file.write(content)
+      file.flush
+      yield file.path
+    end
+  end
+
+  describe 'validate subcommand with file' do
+    it 'exits 0 when predicate returns truthy value' do
+      with_temp_predicate("->(model) { true }\n") do |path|
+        _out, _err, status = run_cli_with_status(
+          '--root', root,
+          '--resultset', 'coverage',
+          'validate', path
+        )
+        expect(status).to eq(0)
+      end
+    end
+
+    it 'exits 1 when predicate returns falsy value' do
+      with_temp_predicate("->(model) { false }\n") do |path|
+        _out, _err, status = run_cli_with_status(
+          '--root', root,
+          '--resultset', 'coverage',
+          'validate', path
+        )
+        expect(status).to eq(1)
+      end
+    end
+
+    it 'exits 2 when predicate raises an error' do
+      with_temp_predicate("->(model) { raise 'Boom!' }\n") do |path|
+        _out, err, status = run_cli_with_status(
+          '--root', root,
+          '--resultset', 'coverage',
+          'validate', path
+        )
+        expect(status).to eq(2)
+        expect(err).to include('Predicate error: Boom!')
+      end
+    end
+
+    it 'shows backtrace when predicate errors with --error-mode debug' do
+      with_temp_predicate("->(model) { raise 'Boom!' }\n") do |path|
+        _out, err, status = run_cli_with_status(
+          '--error-mode', 'debug',
+          '--root', root,
+          '--resultset', 'coverage',
+          'validate', path
+        )
+        expect(status).to eq(2)
+        expect(err).to include('Predicate error: Boom!')
+        # With trace mode, should show backtrace
+        expect(err).to match(/predicate.*\.rb:\d+/)
+      end
+    end
+
+    it 'exits 2 when predicate file is not found' do
+      _out, err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '/nonexistent/predicate.rb'
+      )
+      expect(status).to eq(2)
+      expect(err).to include('Predicate file not found')
+    end
+
+    it 'exits 2 when predicate has syntax error' do
+      with_temp_predicate("-> { this is invalid syntax\n") do |path|
+        _out, err, status = run_cli_with_status(
+          '--root', root,
+          '--resultset', 'coverage',
+          'validate', path
+        )
+        expect(status).to eq(2)
+        expect(err).to include('Syntax error in predicate file')
+      end
+    end
+
+    it 'exits 2 when predicate is not callable' do
+      with_temp_predicate("42\n") do |path|
+        _out, err, status = run_cli_with_status(
+          '--root', root,
+          '--resultset', 'coverage',
+          'validate', path
+        )
+        expect(status).to eq(2)
+        expect(err).to include('Predicate must be callable')
+      end
+    end
+
+    it 'provides model to predicate that can query coverage' do
+      # Test that the predicate receives a working CoverageModel
+      with_temp_predicate(<<~RUBY) do |path|
+        ->(model) do
+          # Access coverage data via the model
+          summary = model.summary_for('lib/foo.rb')
+          summary['summary']['percentage'] > 50  # Should be true for foo.rb
+        end
+      RUBY
+        _out, _err, status = run_cli_with_status(
+          '--root', root,
+          '--resultset', 'coverage',
+          'validate', path
+        )
+        expect(status).to eq(0)
+      end
+    end
+  end
+
+  describe 'validate subcommand with -i/--inline flag' do
+    it 'exits 0 when predicate code returns truthy value' do
+      _out, _err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '-i', '->(model) { true }'
+      )
+      expect(status).to eq(0)
+    end
+
+    it 'exits 1 when predicate code returns falsy value' do
+      _out, _err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '-i', '->(model) { false }'
+      )
+      expect(status).to eq(1)
+    end
+
+    it 'exits 2 when predicate code raises an error' do
+      _out, err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '-i', "->(model) { raise 'Boom!' }"
+      )
+      expect(status).to eq(2)
+      expect(err).to include('Predicate error: Boom!')
+    end
+
+    it 'exits 2 when predicate code has syntax error' do
+      _out, err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '-i', '-> { invalid syntax'
+      )
+      expect(status).to eq(2)
+      expect(err).to include('Syntax error in predicate code')
+    end
+
+    it 'exits 2 when predicate code is not callable' do
+      _out, err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '-i', '42'
+      )
+      expect(status).to eq(2)
+      expect(err).to include('Predicate must be callable')
+    end
+
+    it 'provides model to predicate that can query coverage' do
+      code = <<~RUBY.strip
+        ->(model) { model.summary_for('lib/foo.rb')['summary']['percentage'] > 50 }
+      RUBY
+      _out, _err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '-i', code
+      )
+      expect(status).to eq(0)
+    end
+  end
+
+  describe 'error handling' do
+    it 'raises error when no file or -i flag provided' do
+      _out, err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate'
+      )
+      expect(status).to eq(1)
+      expect(err).to include('validate <file> | -i <code>')
+    end
+
+    it 'raises error when -i flag provided without code' do
+      _out, err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '-i'
+      )
+      expect(status).to eq(1)
+      expect(err).to include('validate -i <code>')
+    end
+
+    it 'raises error when unknown option is provided' do
+      _out, err, status = run_cli_with_status(
+        '--root', root,
+        '--resultset', 'coverage',
+        'validate', '--unknown-option'
+      )
+      expect(status).to eq(1)
+      expect(err).to include('Unknown option for validate: --unknown-option')
+    end
+  end
+end