simplecov-mcp 0.3.0 → 1.0.0

data/spec/model_staleness_spec.rb

@@ -3,30 +3,30 @@
 require 'spec_helper'
 
 RSpec.describe SimpleCovMcp::CoverageModel do
-  let(:root) { (FIXTURES / 'project1').to_s }
-  
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+
   def with_stubbed_coverage_timestamp(ts) = begin
-    allow(SimpleCovMcp::CovUtil).to receive(:latest_timestamp).and_return(ts)
+    mock_resultset_with_timestamp(root, ts)
     yield
   end
 
   it "raises stale error when staleness mode is 'error' and file is newer" do
-    with_stubbed_coverage_timestamp(0) do
+    with_stubbed_coverage_timestamp(VERY_OLD_TIMESTAMP) do
       model = described_class.new(root: root, staleness: 'error')
-      expect {
+      expect do
         model.summary_for('lib/foo.rb')
-      }.to raise_error(SimpleCovMcp::CoverageDataStaleError, /stale/i)
+      end.to raise_error(SimpleCovMcp::CoverageDataStaleError, /stale/i)
     end
   end
 
   it "does not check staleness when mode is 'off'" do
-    with_stubbed_coverage_timestamp(0) 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(0) do
+    with_stubbed_coverage_timestamp(VERY_OLD_TIMESTAMP) do
       model = described_class.new(root: root, staleness: 'error')
       expect { model.all_files }.to raise_error(SimpleCovMcp::CoverageDataProjectStaleError)
     end
@@ -38,12 +38,42 @@ RSpec.describe SimpleCovMcp::CoverageModel do
       begin
         File.write(tmp, "# new file\n")
         model = described_class.new(root: root, staleness: 'error')
-        expect {
+        expect do
           model.all_files(tracked_globs: ['lib/**/*.rb'])
-        }.to raise_error(SimpleCovMcp::CoverageDataProjectStaleError)
+        end.to raise_error(SimpleCovMcp::CoverageDataProjectStaleError)
       ensure
         File.delete(tmp) if File.exist?(tmp)
       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(SimpleCovMcp::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,204 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::OptionNormalizers do
+  describe '.normalize_sort_order' do
+    context 'with strict mode (default)' do
+      it 'normalizes "a" to :ascending' do
+        expect(described_class.normalize_sort_order('a')).to eq(:ascending)
+      end
+
+      it 'normalizes "ascending" to :ascending' do
+        expect(described_class.normalize_sort_order('ascending')).to eq(:ascending)
+      end
+
+      it 'normalizes "d" to :descending' do
+        expect(described_class.normalize_sort_order('d')).to eq(:descending)
+      end
+
+      it 'normalizes "descending" to :descending' do
+        expect(described_class.normalize_sort_order('descending')).to eq(:descending)
+      end
+
+      it 'is case-insensitive' do
+        expect(described_class.normalize_sort_order('ASCENDING')).to eq(:ascending)
+        expect(described_class.normalize_sort_order('Descending')).to eq(:descending)
+      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
+      it 'normalizes nil to :full' do
+        expect(described_class.normalize_source_mode(nil)).to eq(:full)
+      end
+
+      it 'normalizes empty string to :full' do
+        expect(described_class.normalize_source_mode('')).to eq(:full)
+      end
+
+      it 'normalizes "f" to :full' do
+        expect(described_class.normalize_source_mode('f')).to eq(:full)
+      end
+
+      it 'normalizes "full" to :full' do
+        expect(described_class.normalize_source_mode('full')).to eq(:full)
+      end
+
+      it 'normalizes "u" to :uncovered' do
+        expect(described_class.normalize_source_mode('u')).to eq(:uncovered)
+      end
+
+      it 'normalizes "uncovered" to :uncovered' do
+        expect(described_class.normalize_source_mode('uncovered')).to eq(:uncovered)
+      end
+
+      it 'is case-insensitive' do
+        expect(described_class.normalize_source_mode('FULL')).to eq(:full)
+        expect(described_class.normalize_source_mode('Uncovered')).to eq(:uncovered)
+      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_stale_mode' do
+    context 'with strict mode (default)' do
+      it 'normalizes "o" to :off' do
+        expect(described_class.normalize_stale_mode('o')).to eq(:off)
+      end
+
+      it 'normalizes "off" to :off' do
+        expect(described_class.normalize_stale_mode('off')).to eq(:off)
+      end
+
+      it 'normalizes "e" to :error' do
+        expect(described_class.normalize_stale_mode('e')).to eq(:error)
+      end
+
+      it 'normalizes "error" to :error' do
+        expect(described_class.normalize_stale_mode('error')).to eq(:error)
+      end
+
+      it 'is case-insensitive' do
+        expect(described_class.normalize_stale_mode('OFF')).to eq(:off)
+        expect(described_class.normalize_stale_mode('Error')).to eq(:error)
+      end
+
+      it 'raises OptionParser::InvalidArgument for invalid values' do
+        expect { described_class.normalize_stale_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_stale_mode('invalid', strict: false)).to be_nil
+      end
+
+      it 'still normalizes valid values' do
+        expect(described_class.normalize_stale_mode('e', strict: false)).to eq(:error)
+      end
+    end
+  end
+
+  describe '.normalize_error_mode' do
+    context 'with strict mode (default)' do
+      it 'normalizes "off" to :off' do
+        expect(described_class.normalize_error_mode('off')).to eq(:off)
+      end
+
+      it 'normalizes "on" to :on' do
+        expect(described_class.normalize_error_mode('on')).to eq(:on)
+      end
+
+      it 'normalizes "trace" to :trace' do
+        expect(described_class.normalize_error_mode('trace')).to eq(:trace)
+      end
+
+      it 'normalizes "t" to :trace' do
+        expect(described_class.normalize_error_mode('t')).to eq(:trace)
+      end
+
+      it 'is case-insensitive' do
+        expect(described_class.normalize_error_mode('OFF')).to eq(:off)
+        expect(described_class.normalize_error_mode('On')).to eq(:on)
+        expect(described_class.normalize_error_mode('TRACE')).to eq(:trace)
+      end
+
+      it 'raises OptionParser::InvalidArgument for invalid values' do
+        expect { described_class.normalize_error_mode('invalid') }
+          .to raise_error(OptionParser::InvalidArgument, /invalid argument: invalid/)
+      end
+    end
+
+    context 'with strict: false and default: :on' do
+      it 'returns default for invalid values' do
+        expect(described_class.normalize_error_mode('invalid', strict: false,
+          default: :on)).to eq(:on)
+      end
+
+      it 'returns default for nil' do
+        expect(described_class.normalize_error_mode(nil, strict: false, default: :on)).to eq(:on)
+      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 'constant maps' do
+    it 'has frozen SORT_ORDER_MAP' do
+      expect(described_class::SORT_ORDER_MAP).to be_frozen
+    end
+
+    it 'has frozen SOURCE_MODE_MAP' do
+      expect(described_class::SOURCE_MODE_MAP).to be_frozen
+    end
+
+    it 'has frozen STALE_MODE_MAP' do
+      expect(described_class::STALE_MODE_MAP).to be_frozen
+    end
+
+    it 'has frozen ERROR_MODE_MAP' do
+      expect(described_class::ERROR_MODE_MAP).to be_frozen
+    end
+  end
+end

data/spec/option_parsers/env_options_parser_spec.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::OptionParsers::EnvOptionsParser do
+  let(:parser) { described_class.new }
+
+  around do |example|
+    original_value = ENV['SIMPLECOV_MCP_OPTS']
+    example.run
+  ensure
+    ENV['SIMPLECOV_MCP_OPTS'] = original_value
+  end
+
+  describe '#parse_env_opts' do
+    context 'with valid inputs' do
+      it 'returns empty array when environment variable is not set' do
+        ENV.delete('SIMPLECOV_MCP_OPTS')
+        expect(parser.parse_env_opts).to eq([])
+      end
+
+      it 'returns empty array when environment variable is empty string' do
+        ENV['SIMPLECOV_MCP_OPTS'] = ''
+        expect(parser.parse_env_opts).to eq([])
+      end
+
+      it 'returns empty array when environment variable contains only whitespace' do
+        ENV['SIMPLECOV_MCP_OPTS'] = '   '
+        expect(parser.parse_env_opts).to eq([])
+      end
+
+      it 'parses simple options correctly' do
+        ENV['SIMPLECOV_MCP_OPTS'] = '--error-mode off --json'
+        expect(parser.parse_env_opts).to eq(['--error-mode', 'off', '--json'])
+      end
+
+      it 'handles quoted strings with spaces' do
+        ENV['SIMPLECOV_MCP_OPTS'] = '--resultset "/path/to/my file.json"'
+        expect(parser.parse_env_opts).to eq(['--resultset', '/path/to/my file.json'])
+      end
+
+      it 'handles complex shell escaping scenarios' do
+        ENV['SIMPLECOV_MCP_OPTS'] = '--resultset "/path/with spaces/file.json" --error-mode on'
+        expect(parser.parse_env_opts)
+          .to eq(['--resultset', '/path/with spaces/file.json', '--error-mode', 'on'])
+      end
+
+      it 'handles single quotes' do
+        ENV['SIMPLECOV_MCP_OPTS'] = "--resultset '/path/with spaces/file.json'"
+        expect(parser.parse_env_opts).to eq(['--resultset', '/path/with spaces/file.json'])
+      end
+
+      it 'handles escaped characters' do
+        ENV['SIMPLECOV_MCP_OPTS'] = '--resultset /path/with\\ spaces/file.json'
+        expect(parser.parse_env_opts).to eq(['--resultset', '/path/with spaces/file.json'])
+      end
+
+      it 'handles mixed quoting styles' do
+        ENV['SIMPLECOV_MCP_OPTS'] = '--option1 "value with spaces" --option2 \'another value\''
+        expect(parser.parse_env_opts).to eq(
+          ['--option1', 'value with spaces', '--option2', 'another value']
+        )
+      end
+    end
+
+    context 'with malformed inputs' do
+      it 'raises ConfigurationError for unmatched double quotes' do
+        ENV['SIMPLECOV_MCP_OPTS'] = '--resultset "unterminated string'
+
+        expect do
+          parser.parse_env_opts
+        end.to raise_error(SimpleCovMcp::ConfigurationError, /Invalid SIMPLECOV_MCP_OPTS format/)
+      end
+
+      it 'raises ConfigurationError for unmatched single quotes' do
+        ENV['SIMPLECOV_MCP_OPTS'] = "--resultset 'unterminated string"
+
+        expect do
+          parser.parse_env_opts
+        end.to raise_error(SimpleCovMcp::ConfigurationError, /Invalid SIMPLECOV_MCP_OPTS format/)
+      end
+
+      it 'raises ConfigurationError with descriptive message' do
+        ENV['SIMPLECOV_MCP_OPTS'] = '--option "bad quote'
+
+        expect do
+          parser.parse_env_opts
+        end.to raise_error(SimpleCovMcp::ConfigurationError) do |error|
+          expect(error.message).to include('Invalid SIMPLECOV_MCP_OPTS format')
+          expect(error.message).to include('Unmatched') # from Shellwords error
+        end
+      end
+
+      it 'handles multiple quoting errors' do
+        ENV['SIMPLECOV_MCP_OPTS'] = '"first "second "third'
+
+        expect do
+          parser.parse_env_opts
+        end.to raise_error(SimpleCovMcp::ConfigurationError, /Invalid SIMPLECOV_MCP_OPTS format/)
+      end
+    end
+  end
+
+  describe '#pre_scan_error_mode' do
+    let(:error_mode_normalizer) { parser.send(:method, :normalize_error_mode) }
+
+    context 'when error-mode is found' do
+      it 'extracts error-mode with space separator' do
+        argv = ['--error-mode', 'trace', '--other-option']
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: error_mode_normalizer)
+        expect(result).to eq(:trace)
+      end
+
+      it 'extracts error-mode with equals separator' do
+        argv = ['--error-mode=off', '--other-option']
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: error_mode_normalizer)
+        expect(result).to eq(:off)
+      end
+
+      it 'handles error-mode with equals but empty value' do
+        argv = ['--error-mode=', '--other-option']
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: error_mode_normalizer)
+        # Empty value after = explicitly returns nil (line 32)
+        expect(result).to be_nil
+      end
+
+      it 'returns first error-mode when multiple are present' do
+        argv = ['--error-mode', 'on', '--error-mode', 'off']
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: error_mode_normalizer)
+        expect(result).to eq(:on)
+      end
+    end
+
+    context 'when error-mode is not found' do
+      it 'returns nil when no error-mode is present' do
+        argv = ['--other-option', 'value']
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: error_mode_normalizer)
+        expect(result).to be_nil
+      end
+
+      it 'returns nil for empty argv' do
+        argv = []
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: error_mode_normalizer)
+        expect(result).to be_nil
+      end
+    end
+
+    context 'error handling during pre-scan' do
+      it 'returns nil when normalizer raises an error' do
+        faulty_normalizer = ->(value) { raise StandardError, 'Intentional error' }
+        argv = ['--error-mode', 'on']
+
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: faulty_normalizer)
+        expect(result).to be_nil
+      end
+
+      it 'returns nil when normalizer raises ArgumentError' do
+        faulty_normalizer = ->(value) { raise ArgumentError, 'Bad argument' }
+        argv = ['--error-mode', 'on']
+
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: faulty_normalizer)
+        expect(result).to be_nil
+      end
+
+      it 'returns nil when normalizer raises RuntimeError' do
+        faulty_normalizer = ->(value) { raise RuntimeError, 'Runtime problem' }
+        argv = ['--error-mode=off']
+
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: faulty_normalizer)
+        expect(result).to be_nil
+      end
+    end
+  end
+
+  describe 'integration with ErrorHandlerFactory' do
+    it 'maps trace alias to an accepted error_mode' do
+      mode = parser.pre_scan_error_mode(['--error-mode', 'trace'])
+      expect { SimpleCovMcp::ErrorHandlerFactory.for_cli(error_mode: mode) }.not_to raise_error
+      expect(mode).to eq(:trace)
+    end
+  end
+
+  describe '#normalize_error_mode (private)' do
+    it 'normalizes "off" to :off' do
+      expect(parser.send(:normalize_error_mode, 'off')).to eq(:off)
+      expect(parser.send(:normalize_error_mode, 'OFF')).to eq(:off)
+      expect(parser.send(:normalize_error_mode, 'Off')).to eq(:off)
+    end
+
+    it 'normalizes "on" to :on' do
+      expect(parser.send(:normalize_error_mode, 'on')).to eq(:on)
+      expect(parser.send(:normalize_error_mode, 'ON')).to eq(:on)
+    end
+
+    it 'normalizes "trace" to :trace' do
+      expect(parser.send(:normalize_error_mode, 'trace')).to eq(:trace)
+      expect(parser.send(:normalize_error_mode, 'TRACE')).to eq(:trace)
+    end
+
+    it 'normalizes "t" to :trace' do
+      expect(parser.send(:normalize_error_mode, 't')).to eq(:trace)
+      expect(parser.send(:normalize_error_mode, 'T')).to eq(:trace)
+    end
+
+    it 'defaults unknown values to :on' do
+      expect(parser.send(:normalize_error_mode, 'unknown')).to eq(:on)
+      expect(parser.send(:normalize_error_mode, 'invalid')).to eq(:on)
+      expect(parser.send(:normalize_error_mode, '')).to eq(:on)
+    end
+
+    it 'handles nil by defaulting to :on' do
+      expect(parser.send(:normalize_error_mode, nil)).to eq(:on)
+    end
+  end
+
+  describe 'custom environment variable name' do
+    it 'uses custom environment variable when specified' do
+      custom_parser = described_class.new(env_var: 'CUSTOM_OPTS')
+      ENV['CUSTOM_OPTS'] = '--error-mode off'
+
+      expect(custom_parser.parse_env_opts).to eq(['--error-mode', 'off'])
+    end
+
+    it 'includes custom env var name in error messages' do
+      custom_parser = described_class.new(env_var: 'MY_CUSTOM_VAR')
+      ENV['MY_CUSTOM_VAR'] = '"bad quote'
+
+      expect do
+        custom_parser.parse_env_opts
+      end.to raise_error(SimpleCovMcp::ConfigurationError, /Invalid MY_CUSTOM_VAR format/)
+    end
+  end
+end