simplecov-mcp 0.3.0 → 1.0.0

data/lib/simplecov_mcp/util.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'resolvers/resolver_factory'
+
+module SimpleCovMcp
+  RESULTSET_CANDIDATES = [
+    '.resultset.json',
+    'coverage/.resultset.json',
+    'tmp/.resultset.json'
+  ].freeze
+
+  DEFAULT_LOG_FILESPEC = './simplecov_mcp.log'
+
+  module CovUtil
+    module_function
+
+    def log(msg)
+      log_file = SimpleCovMcp.active_log_file
+
+      case log_file
+      when 'stdout'
+        $stdout.puts "[#{Time.now.iso8601}] #{msg}"
+      when 'stderr'
+        $stderr.puts "[#{Time.now.iso8601}] #{msg}"
+      else
+        # Handles both nil (default) and custom file paths
+        path_to_log = log_file || DEFAULT_LOG_FILESPEC
+        File.open(File.expand_path(path_to_log), 'a') { |f| f.puts "[#{Time.now.iso8601}] #{msg}" }
+      end
+    rescue StandardError => e
+      # Fallback to stderr if file logging fails, but suppress in MCP mode
+      # to avoid interfering with JSON-RPC protocol
+      unless SimpleCovMcp.context.mcp_mode?
+        begin
+          $stderr.puts "[#{Time.now.iso8601}] LOGGING ERROR: #{e.message}"
+          $stderr.puts "[#{Time.now.iso8601}] #{msg}"
+        rescue StandardError
+          # Silently ignore only stderr fallback failures
+        end
+      end
+    end
+
+    def find_resultset(root, resultset: nil)
+      Resolvers::ResolverFactory.find_resultset(root, resultset: resultset)
+    end
+
+    def lookup_lines(cov, file_abs)
+      Resolvers::ResolverFactory.lookup_lines(cov, file_abs)
+    end
+
+    def summary(arr)
+      total = 0
+      covered = 0
+      arr.compact.each do |hits|
+        total += 1
+        covered += 1 if hits.to_i > 0
+      end
+      pct = total.zero? ? 100.0 : ((covered.to_f * 100.0 / total) * 100).round / 100.0
+      { 'covered' => covered, 'total' => total, 'pct' => pct }
+    end
+
+    def uncovered(arr)
+      out = []
+
+      arr.each_with_index do |hits, i|
+        next if hits.nil?
+
+        out << (i + 1) if hits.to_i.zero?
+      end
+      out
+    end
+
+    def detailed(arr)
+      rows = []
+      arr.each_with_index do |hits, i|
+        h = hits&.to_i
+        rows << { 'line' => i + 1, 'hits' => h, 'covered' => h.positive? } if h
+      end
+      rows
+    end
+  end
+end

data/lib/{simple_cov_mcp → simplecov_mcp}/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleCovMcp
-  VERSION = '0.3.0'
+  VERSION = '1.0.0'
 end

data/lib/simplecov_mcp.rb

@@ -1,4 +1,146 @@
 # frozen_string_literal: true
 
-# Convenience single-level require path (backcompat)
-require 'simple_cov_mcp'
+require 'json'
+require 'time'
+require 'pathname'
+require 'optparse'
+require 'mcp'
+require 'mcp/server/transports/stdio_transport'
+
+require_relative 'simplecov_mcp/version'
+require_relative 'simplecov_mcp/app_context'
+require_relative 'simplecov_mcp/util'
+require_relative 'simplecov_mcp/errors'
+require_relative 'simplecov_mcp/error_handler'
+require_relative 'simplecov_mcp/error_handler_factory'
+require_relative 'simplecov_mcp/path_relativizer'
+require_relative 'simplecov_mcp/resultset_loader'
+require_relative 'simplecov_mcp/mode_detector'
+require_relative 'simplecov_mcp/model'
+require_relative 'simplecov_mcp/base_tool'
+require_relative 'simplecov_mcp/tools/coverage_raw_tool'
+require_relative 'simplecov_mcp/tools/coverage_summary_tool'
+require_relative 'simplecov_mcp/tools/uncovered_lines_tool'
+require_relative 'simplecov_mcp/tools/coverage_detailed_tool'
+require_relative 'simplecov_mcp/tools/all_files_coverage_tool'
+require_relative 'simplecov_mcp/tools/coverage_table_tool'
+require_relative 'simplecov_mcp/tools/version_tool'
+require_relative 'simplecov_mcp/tools/help_tool'
+require_relative 'simplecov_mcp/mcp_server'
+require_relative 'simplecov_mcp/cli'
+
+module SimpleCovMcp
+  class << self
+    THREAD_CONTEXT_KEY = :simplecov_mcp_context
+
+    def run(argv)
+      # Parse environment options for mode detection
+      env_opts = parse_env_opts_for_mode_detection
+      full_argv = env_opts + argv
+
+      if ModeDetector.cli_mode?(full_argv)
+        CoverageCLI.new.run(argv) # CLI will re-parse env opts internally
+      else
+        log_file = parse_log_file(full_argv)
+
+        if log_file == 'stdout'
+          raise ConfigurationError,
+            'Logging to stdout is not permitted in MCP server mode as it interferes with ' \
+            "the JSON-RPC protocol. Please use 'stderr' or a file path."
+        end
+
+        handler = ErrorHandlerFactory.for_mcp_server
+        context = create_context(error_handler: handler, log_target: log_file, mode: :mcp_server)
+        with_context(context) { MCPServer.new(context: context).run }
+      end
+    end
+
+    def with_context(context)
+      previous = Thread.current[THREAD_CONTEXT_KEY]
+      Thread.current[THREAD_CONTEXT_KEY] = context
+      yield
+    ensure
+      Thread.current[THREAD_CONTEXT_KEY] = previous
+    end
+
+    def context
+      Thread.current[THREAD_CONTEXT_KEY] || default_context
+    end
+
+    def create_context(error_handler:, log_target: nil, mode: :library)
+      AppContext.new(
+        error_handler: error_handler,
+        log_target: log_target.nil? ? default_context.log_target : log_target,
+        mode: mode
+      )
+    end
+
+    def default_log_file
+      default_context.log_target
+    end
+
+    def default_log_file=(value)
+      previous_default = default_context
+      @default_context = previous_default.with_log_target(value)
+      active = Thread.current[THREAD_CONTEXT_KEY]
+      if active.nil? || active.log_target == previous_default.log_target
+        Thread.current[THREAD_CONTEXT_KEY] = @default_context
+      end
+      value
+    end
+
+    def active_log_file
+      context.log_target
+    end
+
+    def active_log_file=(value)
+      current = Thread.current[THREAD_CONTEXT_KEY]
+      if current
+        Thread.current[THREAD_CONTEXT_KEY] = current.with_log_target(value)
+      else
+        Thread.current[THREAD_CONTEXT_KEY] = default_context.with_log_target(value)
+      end
+      value
+    end
+
+    def error_handler
+      context.error_handler
+    end
+
+    def error_handler=(handler)
+      @default_context = default_context.with_error_handler(handler)
+    end
+
+    private
+
+    def default_context
+      @default_context ||= AppContext.new(
+        error_handler: ErrorHandlerFactory.for_cli,
+        log_target: nil
+      )
+    end
+
+    def parse_log_file(argv)
+      log_file = nil
+      parser = OptionParser.new do |o|
+        # Define the option we're looking for
+        o.on('-l', '--log-file PATH') { |v| log_file = v }
+      end
+      # Parse arguments, but ignore errors and stop at the first non-option
+      parser.order!(argv.dup) {} rescue nil
+      log_file
+    end
+
+    def parse_env_opts_for_mode_detection
+      require 'shellwords'
+      opts_string = ENV['SIMPLECOV_MCP_OPTS']
+      return [] unless opts_string && !opts_string.empty?
+
+      begin
+        Shellwords.split(opts_string)
+      rescue ArgumentError
+        [] # Ignore parsing errors for mode detection
+      end
+    end
+  end
+end

data/spec/MCP_INTEGRATION_TESTS_README.md

@@ -0,0 +1,111 @@
+# MCP Server Protocol Integration Tests
+
+## Overview
+
+This document describes the comprehensive integration tests added for the SimpleCov MCP server protocol in `spec/integration_spec.rb`.
+
+## Test Coverage
+
+The integration tests spawn the actual MCP server as a subprocess and communicate with it via JSON-RPC over stdio, testing the complete end-to-end protocol implementation.
+
+### Tests Added (12 total)
+
+1. **starts MCP server without errors** - Verifies the server starts and responds to basic requests without NameError or other initialization issues
+2. **handles tools/list request** - Confirms all 8 expected tools are properly registered
+3. **executes coverage_summary_tool via JSON-RPC** - Tests single-file coverage summary queries
+4. **executes all_files_coverage_tool via JSON-RPC** - Tests project-wide coverage listing
+5. **executes uncovered_lines_tool via JSON-RPC** - Tests uncovered line detection
+6. **executes help_tool via JSON-RPC** - Tests help/documentation retrieval
+7. **executes version_tool via JSON-RPC** - Tests version information queries
+8. **handles error responses for invalid tool calls** - Verifies graceful error handling
+9. **handles malformed JSON-RPC requests** - Tests robustness against invalid input
+10. **respects --log-file configuration in MCP mode** - Tests logging configuration
+11. **prohibits stdout logging in MCP mode** - Ensures stdout isn't corrupted
+12. **handles multiple sequential requests** - Tests statelessness and multi-request handling
+
+## Why These Tests Are Critical
+
+### Issue #1 from Analysis: Missing `require 'optparse'`
+
+The critical bug (missing `require 'optparse'` in `lib/simplecov_mcp.rb:110`) was not caught by existing tests because:
+
+- Unit tests loaded the full gem which transitively required optparse through the CLI
+- MCP tools were tested in-process without spawning the server
+- No integration tests verified the MCP server startup sequence
+
+### What These Tests Catch
+
+* ✅ **Server Initialization Errors**: NameError, LoadError, missing requires
+* ✅ **Protocol Compliance**: Valid JSON-RPC request/response format
+* ✅ **Tool Registration**: All tools properly configured and accessible
+* ✅ **Data Accuracy**: Coverage data correctly passed from fixtures
+* ✅ **Error Handling**: Graceful responses for invalid requests
+* ✅ **Configuration**: Environment variables and options properly handled
+* ✅ **Statelessness**: Multiple requests handled independently
+* ✅ **Stream Integrity**: Stdout not corrupted by logging
+
+## Test Architecture
+
+### Helper Methods
+
+- **`run_mcp_request(request_hash, timeout: 5)`**: Spawns MCP server, sends JSON-RPC request, returns stdout/stderr/status
+- **`parse_jsonrpc_response(output)`**: Extracts JSON-RPC response from output (handles mixed stderr/stdout)
+
+### Test Fixtures
+
+Uses `spec/fixtures/project1/` with known coverage data:
+- `lib/foo.rb`: 66.67% coverage (2/3 lines, line 2 uncovered)
+- `lib/bar.rb`: 33.33% coverage (1/3 lines)
+
+### Test Execution
+
+```bash
+# Run all MCP integration tests
+bundle exec rspec spec/integration_spec.rb --tag slow
+
+# Run specific integration test
+bundle exec rspec spec/integration_spec.rb:363
+```
+
+## Performance
+
+- Total execution time: ~2.1 seconds for all 12 tests
+- Tagged with `:slow` to allow exclusion from quick test runs
+- Uses `Open3.popen3` for subprocess management
+- 5-second timeout per request (configurable)
+
+## Coverage Impact
+
+These tests increased the overall test count from 272 to 284 examples and improved confidence in the MCP server mode, which is the primary use case for AI assistant integration.
+
+### Before Integration Tests
+- 272 examples
+- Missing `require 'optparse'` bug went undetected
+- MCP server mode untested end-to-end
+
+### After Integration Tests
+- 284 examples
+- MCP server startup verified
+- Full JSON-RPC protocol tested
+- Would catch Issue #1 immediately
+
+## Future Enhancements
+
+Potential additions:
+- Test connection lifecycle (startup, multiple sessions, shutdown)
+- Test concurrent requests (if supported)
+- Test large coverage datasets (performance)
+- Test network transport (if added)
+- Test authentication/authorization (if added)
+
+## Related Files
+
+- `spec/integration_spec.rb` - Main integration test file (lines 308-683)
+- `lib/simplecov_mcp.rb` - Entry point with mode detection
+- `lib/simplecov_mcp/mcp_server.rb` - MCP server implementation
+- `exe/simplecov-mcp` - Executable entry point
+
+## References
+
+- [MCP Protocol Specification](https://modelcontextprotocol.io/)
+- [JSON-RPC 2.0 Specification](https://www.jsonrpc.org/specification)

data/spec/TIMESTAMPS.md

@@ -0,0 +1,48 @@
+# Test Timestamp Documentation
+
+This document explains the timestamp constants used throughout the test suite for consistent and documented test data.
+
+## Constants (defined in `spec_helper.rb`)
+
+### `FIXTURE_COVERAGE_TIMESTAMP = 1_720_000_000`
+- **Human readable**: 2024-07-03 16:26:40 UTC (July 3rd, 2024)
+- **Purpose**: The "generated" timestamp for coverage data in `spec/fixtures/project1/coverage/.resultset.json`
+- **Usage**: Used in tests that verify timestamp parsing and calculations with realistic coverage data
+
+### `VERY_OLD_TIMESTAMP = 0`
+- **Human readable**: 1970-01-01 00:00:00 UTC (Unix epoch)
+- **Purpose**: Simulates extremely stale coverage data (much older than any real file)
+- **Usage**: Used in staleness tests to force stale coverage scenarios
+
+### `TEST_FILE_TIMESTAMP = 1_000`
+- **Human readable**: 1970-01-01 00:16:40 UTC (16 minutes and 40 seconds after epoch)
+- **Purpose**: Used for stale error formatting tests to create predictable time deltas
+- **Usage**: Creates a 1000-second (16m 40s) difference from `VERY_OLD_TIMESTAMP` for delta calculations
+
+## Conversion Reference
+
+To convert timestamps for debugging:
+
+```bash
+# Unix timestamp to human readable
+date -d @1720000000
+# Wed Jul  3 16:26:40 UTC 2024
+
+# Human readable to Unix timestamp  
+date -d "2024-07-03 16:26:40 UTC" +%s
+# 1720000000
+```
+
+## Why These Values?
+
+- **Realistic but static**: `FIXTURE_COVERAGE_TIMESTAMP` is a realistic recent date that won't change
+- **Predictable deltas**: The differences between timestamps create predictable test scenarios
+- **Clear intent**: Named constants make it obvious what each timestamp represents in tests
+
+## Files Using These Constants
+
+- `spec/util_spec.rb` - Tests timestamp parsing from fixture
+- `spec/model_staleness_spec.rb` - Tests staleness detection logic
+- `spec/errors_stale_spec.rb` - Tests stale error message formatting
+- `spec/cli_error_spec.rb` - Tests CLI error handling for stale coverage
+- `spec/fixtures/project1/coverage/.resultset.json` - Contains the actual timestamp data

data/spec/all_files_coverage_tool_spec.rb

@@ -1,43 +1,47 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
-require 'simple_cov_mcp/tools/all_files_coverage_tool'
+require 'simplecov_mcp/tools/all_files_coverage_tool'
 
 RSpec.describe SimpleCovMcp::Tools::AllFilesCoverageTool do
-  let(:root) { (FIXTURES / 'project1').to_s }
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
   let(:server_context) { instance_double('ServerContext').as_null_object }
 
   before do
-    # Stub a response object that accepts a meta keyword, like the real one
-    stub_const('MCP::Tool::Response', Class.new do
-      attr_reader :payload, :meta
-      def initialize(payload, meta: nil)
-        @payload = payload
-        @meta = meta
-      end
-    end)
-  end
-
-  it 'returns files with counts (total/ok/stale) as JSON' do
+    setup_mcp_response_stub
     model = instance_double(SimpleCovMcp::CoverageModel)
     allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
-    allow(model).to receive(:all_files).and_return([
-      { 'file' => "#{root}/lib/foo.rb", 'percentage' => 100.0, 'covered' => 10, 'total' => 10, 'stale' => false },
-      { 'file' => "#{root}/lib/bar.rb", 'percentage' => 50.0,  'covered' => 5,  'total' => 10, 'stale' => true }
-    ])
 
-    response = described_class.call(root: root, server_context: server_context)
-    entry = response.payload.first
-    expect(entry['type']).to eq('resource')
-    expect(entry['resource']).to include('mimeType' => 'application/json')
-    json = JSON.parse(entry['resource']['text'])
+    payload = {
+      'files' => [
+        { 'file' => 'lib/foo.rb', 'percentage' => 100.0, 'covered' => 10, 'total' => 10,
+          'stale' => false },
+        { 'file' => 'lib/bar.rb', 'percentage' => 50.0,  'covered' => 5,  'total' => 10,
+          'stale' => true }
+      ],
+      'counts' => { 'total' => 2, 'ok' => 1, 'stale' => 1 }
+    }
+
+    presenter = instance_double(SimpleCovMcp::Presenters::ProjectCoveragePresenter)
+    allow(SimpleCovMcp::Presenters::ProjectCoveragePresenter).to receive(:new).and_return(presenter)
+    allow(presenter).to receive(:relativized_payload).and_return(payload)
+  end
+
+  subject { described_class.call(root: root, server_context: server_context) }
+
+  it_behaves_like 'an MCP tool that returns text JSON'
 
-    expect(json).to have_key('files')
-    files = json['files']
-    counts = json['counts']
+  it 'returns all files coverage data with counts' do
+    response = subject
+    data, item = expect_mcp_text_json(response, expected_keys: ['files', 'counts'])
+
+    files = data['files']
+    counts = data['counts']
 
     expect(files.length).to eq(2)
     expect(counts).to include('total' => 2).or include(total: 2)
+    expect(files.map { |f| f['file'] }).to eq(['lib/foo.rb', 'lib/bar.rb'])
+
     # ok + stale equals total
     ok = counts[:ok] || counts['ok']
     stale = counts[:stale] || counts['stale']

data/spec/base_tool_spec.rb

@@ -3,10 +3,11 @@
 require 'spec_helper'
 
 RSpec.describe SimpleCovMcp::BaseTool do
-  let(:handler) { SimpleCovMcp::ErrorHandler.new(log_errors: true, show_stack_traces: false, logger: test_logger) }
+  let(:handler) { SimpleCovMcp::ErrorHandler.new(error_mode: :on, logger: test_logger) }
   let(:test_logger) do
     Class.new do
       attr_reader :messages
+
       def initialize; @messages = []; end
       def error(msg); @messages << msg; end
     end.new
@@ -19,12 +20,7 @@ RSpec.describe SimpleCovMcp::BaseTool do
       nil
     end
     SimpleCovMcp.error_handler = handler
-    # Stub MCP::Tool::Response once for all examples; capture the payload
-    fake_resp = Class.new do
-      attr_reader :payload
-      def initialize(payload) = @payload = payload
-    end
-    stub_const('MCP::Tool::Response', fake_resp)
+    setup_mcp_response_stub
   end
 
   after do
@@ -32,11 +28,16 @@ RSpec.describe SimpleCovMcp::BaseTool do
   end
 
   shared_examples 'friendly response and logged' do
-    it 'returns friendly text and logs' do
-      resp = described_class.handle_mcp_error(error, tool)
+    it 'returns friendly text' do
+      resp = described_class.handle_mcp_error(error, tool, error_mode: :on)
+      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)
-      expect(test_logger.messages.join).to include(log_fragment)
     end
   end
 

data/spec/cli/show_default_report_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::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.stale_mode = :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.json = true
+
+      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_config_spec.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::CLIConfig do
+  describe '#initialize' do
+    it 'creates a config with default values' do
+      config = described_class.new
+      expect(config.root).to eq('.')
+      expect(config.json).to be false
+      expect(config.sort_order).to eq(:ascending)
+      expect(config.source_context).to eq(2)
+      expect(config.error_mode).to eq(:on)
+      expect(config.stale_mode).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
+      expect(config.success_predicate).to be_nil
+    end
+
+    it 'allows overriding defaults via keyword arguments' do
+      config = described_class.new(
+        root: '/custom',
+        json: true,
+        sort_order: :descending,
+        stale_mode: :error
+      )
+      expect(config.root).to eq('/custom')
+      expect(config.json).to be true
+      expect(config.sort_order).to eq(:descending)
+      expect(config.stale_mode).to eq(:error)
+    end
+
+    it 'is mutable (struct fields can be changed)' do
+      config = described_class.new
+      config.root = '/new/root'
+      config.json = true
+      expect(config.root).to eq('/new/root')
+      expect(config.json).to be true
+    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',
+        stale_mode: :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', json: true)
+      config2 = described_class.new(root: '/foo', json: true)
+      config3 = described_class.new(root: '/bar', json: true)
+
+      expect(config1).to eq(config2)
+      expect(config1).not_to eq(config3)
+    end
+
+    it 'provides readable inspect output' do
+      config = described_class.new(root: '/test', json: true)
+      output = config.inspect
+      expect(output).to include('root="/test"')
+      expect(output).to include('json=true')
+    end
+
+    it 'converts to hash' do
+      config = described_class.new(root: '/test', json: true)
+      hash = config.to_h
+      expect(hash).to be_a(Hash)
+      expect(hash[:root]).to eq('/test')
+      expect(hash[:json]).to be true
+    end
+  end
+
+  describe 'symbol enumerated values' do
+    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 stale_mode' do
+      config = described_class.new(stale_mode: :error)
+      expect(config.stale_mode).to eq(:error)
+      expect(config.stale_mode).to be_a(Symbol)
+    end
+
+    it 'uses symbols for error_mode' do
+      config = described_class.new(error_mode: :trace)
+      expect(config.error_mode).to eq(:trace)
+      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