cov-loupe 3.0.0

data/spec/model_error_handling_spec.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CovLoupe::CoverageModel, 'error handling' do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:malformed_resultset) do
+    {
+      'RSpec' => {
+        'coverage' => 'not_a_hash' # Should be a hash, not a string
+      }
+    }
+  end
+
+  describe 'initialization error handling' do
+    let(:valid_resultset) do
+      {
+        'RSpec' => {
+          'coverage' => {
+            "lib/foo\x00bar.rb" => { 'lines' => [1, 0, 1] } # Path with NULL byte
+          }
+        },
+        'timestamp' => 1000
+      }
+    end
+    let(:malformed_resultset) do
+      {
+        'RSpec' => {
+          'coverage' => 'not_a_hash' # Should be a hash, not a string
+        }
+      }
+    end
+
+    it 'raises CoverageDataError with message detail for invalid JSON format' do
+      # Mock JSON.parse to raise JSON::ParserError
+      allow(JSON).to receive(:load_file).with(anything)
+        .and_raise(JSON::ParserError.new('unexpected token'))
+
+      expect do
+        described_class.new(root: root, resultset: 'coverage')
+      end.to raise_error(CovLoupe::CoverageDataError) do |error|
+        expect(error.message).to include('Invalid coverage data format')
+        expect(error.message).to include('unexpected token')
+      end
+    end
+
+    it 'raises FilePermissionError when coverage file is not readable' do
+      # Mock File.read to raise Errno::EACCES
+      allow(JSON).to receive(:load_file).with(anything).and_raise(
+        Errno::EACCES.new('Permission denied')
+      )
+
+      expect do
+        described_class.new(root: root, resultset: 'coverage')
+      end.to raise_error(CovLoupe::FilePermissionError) do |error|
+        expect(error.message).to include('Permission denied reading coverage data')
+        expect(error.message).to include('Permission denied')
+      end
+    end
+
+
+    it 'raises CoverageDataError when resultset structure is invalid (TypeError)' do
+      allow(JSON).to receive(:load_file).with(anything).and_return(malformed_resultset)
+
+      expect do
+        described_class.new(root: root, resultset: 'coverage')
+      end.to raise_error(CovLoupe::CoverageDataError) do |error|
+        expect(error.message).to include('Invalid coverage data structure')
+      end
+    end
+
+    it 'raises CoverageDataError when resultset structure causes NoMethodError' do
+      # Create a resultset structure that will cause NoMethodError
+      malformed_resultset = {
+        'RSpec' => {
+          'coverage' => {
+            'file.rb' => nil # Should have 'lines' key, this will cause NoMethodError
+          }
+        }
+      }
+
+      allow(File).to receive(:open).and_call_original
+      allow(File).to receive(:open).with(end_with('.resultset.json'), 'r')
+        .and_return(StringIO.new(malformed_resultset.to_json))
+
+      broken_map = instance_double('CoverageMap')
+      allow(broken_map).to receive(:transform_keys)
+        .and_raise(NoMethodError.new("undefined method `upcase' for nil:NilClass"))
+      allow(CovLoupe::ResultsetLoader).to receive(:load).and_return(
+        CovLoupe::ResultsetLoader::Result.new(coverage_map: broken_map,
+          timestamp: 0, suite_names: ['RSpec'])
+      )
+
+      expect do
+        described_class.new(root: root, resultset: 'coverage')
+      end.to raise_error(CovLoupe::CoverageDataError) do |error|
+        expect(error.message).to include('Invalid coverage data structure')
+      end
+    end
+
+
+
+
+    it 'raises CoverageDataError when path operations raise ArgumentError' do
+      allow(JSON).to receive(:load_file).with(end_with('.resultset.json'))
+        .and_return(valid_resultset)
+
+      # Mock File.absolute_path to raise ArgumentError when called with the problematic path
+      # But allow it to work for the root initialization
+      allow(File).to receive(:absolute_path).and_call_original
+      allow(File).to receive(:absolute_path).with(include("\x00"), anything).and_raise(
+        ArgumentError.new('string contains null byte')
+      )
+
+      expect do
+        described_class.new(root: root, resultset: 'coverage')
+      end.to raise_error(CovLoupe::CoverageDataError) do |error|
+        expect(error.message).to include('Invalid path in coverage data')
+        expect(error.message).to include('null byte')
+      end
+    end
+
+    it 'preserves error context in JSON::ParserError messages' do
+      allow(JSON).to receive(:load_file).with(anything).and_raise(
+        JSON::ParserError.new('765: unexpected token at line 3, column 5')
+      )
+
+      expect do
+        described_class.new(root: root, resultset: 'coverage')
+      end.to raise_error(CovLoupe::CoverageDataError) do |error|
+        # Verify the original error message details are preserved
+        expect(error.message).to include('765')
+        expect(error.message).to include('line 3')
+      end
+    end
+
+    it 'provides helpful error for permission issues with file path' do
+      # Mock to raise permission error with actual file path
+      resultset_path = File.join(root, 'coverage', '.resultset.json')
+      allow(JSON).to receive(:load_file).with(resultset_path).and_raise(
+        Errno::EACCES.new(resultset_path)
+      )
+
+      expect do
+        described_class.new(root: root, resultset: 'coverage')
+      end.to raise_error(CovLoupe::FilePermissionError) do |error|
+        expect(error.message).to include('Permission denied')
+        expect(error.message).to match(/\.resultset\.json/)
+      end
+    end
+  end
+
+  describe 'error context preservation' do
+    it 'includes original exception message for JSON::ParserError' do
+      allow(JSON).to receive(:load_file).with(anything)
+        .and_raise(JSON::ParserError.new('unexpected character at byte 42'))
+
+      expect do
+        described_class.new(root: root, resultset: 'coverage')
+      end.to raise_error(CovLoupe::CoverageDataError) do |error|
+        expect(error.message).to include('unexpected character at byte 42')
+      end
+    end
+
+    it 'includes original exception message for Errno::EACCES' do
+      resultset_path = File.join(root, 'coverage', '.resultset.json')
+      allow(JSON).to receive(:load_file).with(resultset_path).and_raise(Errno::EACCES.new(resultset_path))
+
+      expect do
+        described_class.new(root: root, resultset: 'coverage')
+      end.to raise_error(CovLoupe::FilePermissionError) do |error|
+        expect(error.message).to include(resultset_path)
+      end
+    end
+
+    it 'includes original exception message for TypeError' do
+      # Mock to cause TypeError within ResultsetLoader's processing
+      allow(JSON).to receive(:load_file).with(anything).and_return(malformed_resultset)
+
+      expect do
+        described_class.new(root: root, resultset: 'coverage')
+      end.to raise_error(CovLoupe::CoverageDataError) do |error|
+        expect(error.message).to include('Invalid coverage data structure')
+        expect(error.message).to include('suite "RSpec"')
+      end
+    end
+  end
+
+  describe 'RuntimeError handling from find_resultset' do
+    it 'converts RuntimeError to CoverageDataError with helpful message' do
+      # Mock find_resultset to raise RuntimeError (simulating missing resultset)
+      allow(CovLoupe::CovUtil).to receive(:find_resultset).and_raise(
+        RuntimeError.new('Specified resultset not found: /nonexistent/path/.resultset.json')
+      )
+
+      expect do
+        described_class.new(root: root, resultset: '/nonexistent/path')
+      end.to raise_error(CovLoupe::ResultsetNotFoundError) do |error|
+        expect(error.message).to include('Specified resultset not found')
+      end
+    end
+
+    it 'handles RuntimeError with generic messages' do
+      # Test RuntimeError with any generic message that includes 'resultset'
+      allow(CovLoupe::CovUtil).to receive(:find_resultset).and_raise(
+        RuntimeError.new('Something went wrong during resultset lookup')
+      )
+
+      expect do
+        described_class.new(root: root, resultset: 'coverage')
+      end.to raise_error(CovLoupe::ResultsetNotFoundError) do |error|
+        expect(error.message).to include('Something went wrong during resultset lookup')
+      end
+    end
+
+    it 'converts RuntimeError without "resultset" in message to CoverageDataError' do
+      # Test RuntimeError that does NOT contain 'resultset' in its message
+      # This exercises the else branch in the RuntimeError rescue clause
+      allow(CovLoupe::CovUtil).to receive(:find_resultset).and_raise(
+        RuntimeError.new('Some completely unrelated runtime error')
+      )
+
+      expect do
+        described_class.new(root: root, resultset: 'coverage')
+      end.to raise_error(CovLoupe::CoverageDataError) do |error|
+        expect(error.message).to include('Failed to load coverage data')
+        expect(error.message).to include('Some completely unrelated runtime error')
+      end
+    end
+  end
+
+  describe 'all_files error handling' do
+    it 'skips files that raise FileError during coverage lookup' do
+      # This exercises the `next` statement in the all_files loop when FileError is raised
+      model = described_class.new(root: root, resultset: 'coverage')
+
+      # Mock lookup_lines to raise FileError for one specific file
+      allow(CovLoupe::CovUtil).to receive(:lookup_lines).and_call_original
+      allow(CovLoupe::CovUtil).to receive(:lookup_lines)
+        .with(anything, include('/lib/foo.rb'))
+        .and_raise(CovLoupe::FileError.new('Corrupted coverage entry'))
+
+      # Should not raise, just skip the problematic file
+      result = model.all_files(check_stale: false)
+
+      # The result should contain bar.rb but not foo.rb
+      file_names = result.map { |r| File.basename(r['file']) }
+      expect(file_names).to include('bar.rb')
+      expect(file_names).not_to include('foo.rb')
+    end
+  end
+
+  describe 'resolve method error handling' do
+    it 'converts RuntimeError from lookup_lines to FileError' do
+      # This exercises the RuntimeError rescue clause in the resolve method
+      model = described_class.new(root: root, resultset: 'coverage')
+
+      # Mock lookup_lines to raise RuntimeError for a specific file
+      allow(CovLoupe::CovUtil).to receive(:lookup_lines)
+        .and_raise(RuntimeError.new('Unexpected runtime error during lookup'))
+
+      expect do
+        model.summary_for('nonexistent_file.rb')
+      end.to raise_error(CovLoupe::FileError) do |error|
+        expect(error.message).to include('No coverage data found for file')
+      end
+    end
+  end
+end

data/spec/model_staleness_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tempfile'
+
+RSpec.describe CovLoupe::CoverageModel do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+
+  def with_stubbed_coverage_timestamp(timestamp)
+    mock_resultset_with_timestamp(root, timestamp)
+    yield
+  end
+
+  it "raises stale error when staleness mode is 'error' and file is newer" do
+    with_stubbed_coverage_timestamp(VERY_OLD_TIMESTAMP) do
+      model = described_class.new(root: root, staleness: :error)
+      expect do
+        model.summary_for('lib/foo.rb')
+      end.to raise_error(CovLoupe::CoverageDataStaleError, /stale/i)
+    end
+  end
+
+  it "does not check staleness when mode is 'off'" do
+    with_stubbed_coverage_timestamp(VERY_OLD_TIMESTAMP) do
+      model = described_class.new(root: root, staleness: :off)
+      expect { model.summary_for('lib/foo.rb') }.not_to raise_error
+    end
+  end
+
+  it 'all_files raises project-level stale when any source file is newer than coverage' do
+    with_stubbed_coverage_timestamp(VERY_OLD_TIMESTAMP) do
+      model = described_class.new(root: root, staleness: :error)
+      expect { model.all_files }.to raise_error(CovLoupe::CoverageDataProjectStaleError)
+    end
+  end
+
+  it 'all_files detects new files via tracked_globs' do
+    with_stubbed_coverage_timestamp(Time.now.to_i) do
+      Tempfile.create(['brand_new_file', '.rb'], File.join(root, 'lib')) do |f|
+        f.write("# new file\n")
+        f.flush
+        model = described_class.new(root: root, staleness: :error)
+        expect do
+          model.all_files(tracked_globs: ['lib/**/*.rb'])
+        end.to raise_error(CovLoupe::CoverageDataProjectStaleError)
+      end
+    end
+  end
+
+  describe 'timestamp normalization' do
+    it 'parses created_at strings to epoch seconds' do
+      created_at = Time.new(2024, 7, 3, 16, 26, 40, '-07:00')
+      mock_resultset_with_created_at(root, created_at.strftime('%Y-%m-%d %H:%M:%S %z'))
+
+      model = described_class.new(root: root, staleness: :off)
+
+      expect(model.instance_variable_get(:@cov_timestamp)).to eq(created_at.to_i)
+    end
+
+    it 'propagates parsed created_at timestamps into stale errors' do
+      file_mtime = File.mtime(File.join(root, 'lib', 'foo.rb'))
+      created_at_time = (file_mtime + 3600).utc
+      # Use mismatched coverage (3 lines instead of 4) to trigger staleness
+      mismatched_coverage = {
+        File.join(root, 'lib', 'foo.rb') => { 'lines' => [1, 0, nil] }
+      }
+      mock_resultset_with_created_at(root, created_at_time.iso8601, coverage: mismatched_coverage)
+
+      model = described_class.new(root: root, staleness: :error)
+
+      expect(model.instance_variable_get(:@cov_timestamp)).to eq(created_at_time.to_i)
+      expect do
+        model.summary_for('lib/foo.rb')
+      end.to raise_error(CovLoupe::CoverageDataStaleError) { |error|
+        expect(error.cov_timestamp).to eq(created_at_time.to_i)
+      }
+    end
+  end
+end

data/spec/option_normalizers_spec.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CovLoupe::OptionNormalizers do
+  describe '.normalize_sort_order' do
+    context 'with strict mode (default)' do
+      [
+        ['a', :ascending],
+        ['ascending', :ascending],
+        ['d', :descending],
+        ['descending', :descending],
+        ['ASCENDING', :ascending],
+        ['Descending', :descending]
+      ].each do |input, expected|
+        it "normalizes '#{input}' to #{expected}" do
+          expect(described_class.normalize_sort_order(input)).to eq(expected)
+        end
+      end
+
+      it 'raises OptionParser::InvalidArgument for invalid values' do
+        expect { described_class.normalize_sort_order('invalid') }
+          .to raise_error(OptionParser::InvalidArgument, /invalid argument: invalid/)
+      end
+    end
+
+    context 'with strict: false' do
+      it 'returns nil for invalid values' do
+        expect(described_class.normalize_sort_order('invalid', strict: false)).to be_nil
+      end
+
+      it 'still normalizes valid values' do
+        expect(described_class.normalize_sort_order('a', strict: false)).to eq(:ascending)
+      end
+    end
+  end
+
+  describe '.normalize_source_mode' do
+    context 'with strict mode (default)' do
+      [nil, ''].each do |input|
+        it "raises OptionParser::InvalidArgument for #{input.inspect}" do
+          expect { described_class.normalize_source_mode(input) }
+            .to raise_error(OptionParser::InvalidArgument, /invalid argument/)
+        end
+      end
+
+      [
+        ['f', :full],
+        ['full', :full],
+        ['u', :uncovered],
+        ['uncovered', :uncovered],
+        ['FULL', :full],
+        ['Uncovered', :uncovered]
+      ].each do |input, expected|
+        it "normalizes '#{input}' to #{expected}" do
+          expect(described_class.normalize_source_mode(input)).to eq(expected)
+        end
+      end
+
+      it 'raises OptionParser::InvalidArgument for invalid values' do
+        expect { described_class.normalize_source_mode('invalid') }
+          .to raise_error(OptionParser::InvalidArgument, /invalid argument: invalid/)
+      end
+    end
+
+    context 'with strict: false' do
+      it 'returns nil for invalid values' do
+        expect(described_class.normalize_source_mode('invalid', strict: false)).to be_nil
+      end
+
+      it 'still normalizes valid values' do
+        expect(described_class.normalize_source_mode('u', strict: false)).to eq(:uncovered)
+      end
+    end
+  end
+
+  describe '.normalize_staleness' do
+    context 'with strict mode (default)' do
+      [
+        ['o', :off],
+        ['off', :off],
+        ['e', :error],
+        ['error', :error],
+        ['OFF', :off],
+        ['Error', :error]
+      ].each do |input, expected|
+        it "normalizes '#{input}' to #{expected}" do
+          expect(described_class.normalize_staleness(input)).to eq(expected)
+        end
+      end
+
+      it 'raises OptionParser::InvalidArgument for invalid values' do
+        expect { described_class.normalize_staleness('invalid') }
+          .to raise_error(OptionParser::InvalidArgument, /invalid argument: invalid/)
+      end
+    end
+
+    context 'with strict: false' do
+      it 'returns nil for invalid values' do
+        expect(described_class.normalize_staleness('invalid', strict: false)).to be_nil
+      end
+
+      it 'still normalizes valid values' do
+        expect(described_class.normalize_staleness('e', strict: false)).to eq(:error)
+      end
+    end
+  end
+
+  describe '.normalize_error_mode' do
+    context 'with strict mode (default)' do
+      [
+        ['off', :off],
+        ['o', :off],
+        ['log', :log],
+        ['l', :log],
+        ['debug', :debug],
+        ['d', :debug],
+        ['OFF', :off],
+        ['Log', :log],
+        ['DEBUG', :debug]
+      ].each do |input, expected|
+        it "normalizes '#{input}' to #{expected}" do
+          expect(described_class.normalize_error_mode(input)).to eq(expected)
+        end
+      end
+
+      ['invalid', 'on', 'trace'].each do |input|
+        it "raises OptionParser::InvalidArgument for '#{input}'" do
+          expect { described_class.normalize_error_mode(input) }
+            .to raise_error(OptionParser::InvalidArgument, /invalid argument: #{input}/)
+        end
+      end
+    end
+
+    context 'with strict: false and default: :log' do
+      [['invalid', :log], [nil, :log]].each do |input, expected|
+        it "returns default #{expected} for #{input.inspect}" do
+          expect(described_class.normalize_error_mode(input, strict: false,
+            default: :log)).to eq(expected)
+        end
+      end
+
+      it 'still normalizes valid values' do
+        expect(described_class.normalize_error_mode('off', strict: false)).to eq(:off)
+      end
+    end
+
+    context 'with custom default' do
+      it 'returns custom default for invalid values when not strict' do
+        expect(described_class.normalize_error_mode('invalid', strict: false,
+          default: :off)).to eq(:off)
+      end
+    end
+  end
+
+  describe '.normalize_format' do
+    context 'with strict mode (default)' do
+      [
+        ['t', :table],
+        ['table', :table],
+        ['j', :json],
+        ['json', :json],
+        ['pretty_json', :pretty_json],
+        ['pretty-json', :pretty_json],
+        ['y', :yaml],
+        ['yaml', :yaml],
+        ['a', :awesome_print],
+        ['awesome_print', :awesome_print],
+        ['ap', :awesome_print],
+        ['TABLE', :table],
+        ['Json', :json]
+      ].each do |input, expected|
+        it "normalizes '#{input}' to #{expected}" do
+          expect(described_class.normalize_format(input)).to eq(expected)
+        end
+      end
+
+      it 'raises OptionParser::InvalidArgument for invalid values' do
+        expect { described_class.normalize_format('invalid') }
+          .to raise_error(OptionParser::InvalidArgument, /invalid argument: invalid/)
+      end
+    end
+
+    context 'with strict: false' do
+      it 'returns nil for invalid values' do
+        expect(described_class.normalize_format('invalid', strict: false)).to be_nil
+      end
+
+      it 'still normalizes valid values' do
+        expect(described_class.normalize_format('json', strict: false)).to eq(:json)
+      end
+    end
+  end
+
+  describe 'constant maps' do
+    [:SORT_ORDER_MAP, :SOURCE_MODE_MAP, :STALENESS_MAP, :ERROR_MODE_MAP,
+     :FORMAT_MAP].each do |const|
+      it "has frozen #{const}" do
+        expect(described_class.const_get(const)).to be_frozen
+      end
+    end
+  end
+end