simplecov-mcp 0.3.0 → 1.0.0

data/spec/logging_fallback_spec.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Logging Fallback Behavior' do
+  describe 'CovUtil.log error handling' do
+    context 'when file logging fails in library mode' do
+      it 'falls back to stderr with error message' do
+        # Set up library mode context
+        context = SimpleCovMcp.create_context(
+          error_handler: SimpleCovMcp::ErrorHandlerFactory.for_library,
+          log_target: '/invalid/path/that/does/not/exist.log',
+          mode: :library
+        )
+
+        stderr_output = nil
+        SimpleCovMcp.with_context(context) do
+          silence_output do |_stdout, stderr|
+            SimpleCovMcp::CovUtil.log('test message')
+            stderr_output = stderr.string
+          end
+        end
+
+        expect(stderr_output).to include('LOGGING ERROR')
+        expect(stderr_output).to include('test message')
+      end
+    end
+
+    context 'when file logging fails in CLI mode' do
+      it 'falls back to stderr with error message' do
+        # Set up CLI mode context
+        context = SimpleCovMcp.create_context(
+          error_handler: SimpleCovMcp::ErrorHandlerFactory.for_cli,
+          log_target: '/invalid/path/that/does/not/exist.log',
+          mode: :cli
+        )
+
+        stderr_output = nil
+        SimpleCovMcp.with_context(context) do
+          silence_output do |_stdout, stderr|
+            SimpleCovMcp::CovUtil.log('test message')
+            stderr_output = stderr.string
+          end
+        end
+
+        expect(stderr_output).to include('LOGGING ERROR')
+        expect(stderr_output).to include('test message')
+      end
+    end
+
+    context 'when file logging fails in MCP server mode' do
+      it 'suppresses stderr output to avoid interfering with JSON-RPC' do
+        # Set up MCP server mode context
+        context = SimpleCovMcp.create_context(
+          error_handler: SimpleCovMcp::ErrorHandlerFactory.for_mcp_server,
+          log_target: '/invalid/path/that/does/not/exist.log',
+          mode: :mcp_server
+        )
+
+        stderr_output = nil
+        SimpleCovMcp.with_context(context) do
+          silence_output do |_stdout, stderr|
+            SimpleCovMcp::CovUtil.log('test message')
+            stderr_output = stderr.string
+          end
+        end
+
+        expect(stderr_output).to be_empty
+      end
+    end
+
+    context 'when logging succeeds' do
+      it 'does not write to stderr' do
+        Dir.mktmpdir do |dir|
+          log_file = File.join(dir, 'test.log')
+          context = SimpleCovMcp.create_context(
+            error_handler: SimpleCovMcp::ErrorHandlerFactory.for_library,
+            log_target: log_file,
+            mode: :library
+          )
+
+          stderr_output = nil
+          SimpleCovMcp.with_context(context) do
+            silence_output do |_stdout, stderr|
+              SimpleCovMcp::CovUtil.log('test message')
+              stderr_output = stderr.string
+            end
+          end
+
+          expect(stderr_output).to be_empty
+          expect(File.read(log_file)).to include('test message')
+        end
+      end
+    end
+  end
+
+  describe 'AppContext mode predicates' do
+    it 'correctly identifies library mode' do
+      context = SimpleCovMcp.create_context(
+        error_handler: SimpleCovMcp::ErrorHandlerFactory.for_library,
+        mode: :library
+      )
+      expect(context.library_mode?).to be true
+      expect(context.cli_mode?).to be false
+      expect(context.mcp_mode?).to be false
+    end
+
+    it 'correctly identifies CLI mode' do
+      context = SimpleCovMcp.create_context(
+        error_handler: SimpleCovMcp::ErrorHandlerFactory.for_cli,
+        mode: :cli
+      )
+      expect(context.library_mode?).to be false
+      expect(context.cli_mode?).to be true
+      expect(context.mcp_mode?).to be false
+    end
+
+    it 'correctly identifies MCP server mode' do
+      context = SimpleCovMcp.create_context(
+        error_handler: SimpleCovMcp::ErrorHandlerFactory.for_mcp_server,
+        mode: :mcp_server
+      )
+      expect(context.library_mode?).to be false
+      expect(context.cli_mode?).to be false
+      expect(context.mcp_mode?).to be true
+    end
+  end
+end

data/spec/mcp_logging_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'MCP Mode Logging' do
+  it 'raises a configuration error when --log-file is stdout' do
+    argv = ['--log-file', 'stdout']
+
+    # Mock ModeDetector to force MCP mode
+    allow(SimpleCovMcp::ModeDetector).to receive(:cli_mode?).and_return(false)
+
+    expect do
+      SimpleCovMcp.run(argv)
+    end.to raise_error(SimpleCovMcp::ConfigurationError,
+      /Logging to stdout is not permitted in MCP server mode/)
+  end
+
+  it 'allows stderr logging in MCP mode' do
+    argv = ['--log-file', 'stderr']
+    original_target = SimpleCovMcp.active_log_file
+
+    # Mock ModeDetector to force MCP mode
+    allow(SimpleCovMcp::ModeDetector).to receive(:cli_mode?).and_return(false)
+
+    # The server would normally start here; stub it so we can capture the context without side effects.
+    mcp_server_double = instance_double(SimpleCovMcp::MCPServer, run: true)
+    captured_context = nil
+    allow(SimpleCovMcp::MCPServer).to receive(:new) do |context:|
+      # Record the context that the MCP server receives to ensure the log target was honored.
+      captured_context = context
+      mcp_server_double
+    end
+
+    expect do
+      SimpleCovMcp.run(argv)
+    end.not_to raise_error
+
+    # Server boot should have been given a context that points stdout logging to stderr.
+    expect(captured_context).not_to be_nil
+    expect(captured_context.log_target).to eq('stderr')
+    # After the run, the original active context should be restored.
+    expect(SimpleCovMcp.active_log_file).to eq(original_target)
+  end
+end

data/spec/mcp_server_integration_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'MCP Server Bootstrap' do
+  it 'does not crash on startup in non-TTY environments' do
+    # Simulate a non-TTY environment, which should trigger MCP mode
+    allow(STDIN).to receive(:tty?).and_return(false)
+
+    # The server will try to run, but we only need to ensure it gets past
+    # the point where the NameError would have occurred. We can mock the
+    # server's run method to prevent it from hanging while waiting for input.
+    mcp_server_instance = instance_double(SimpleCovMcp::MCPServer)
+    allow(SimpleCovMcp::MCPServer).to receive(:new).and_return(mcp_server_instance)
+    allow(mcp_server_instance).to receive(:run)
+
+    # The key assertion is that this code executes without raising a NameError
+    # or any other exception related to the bootstrap process.
+    expect { SimpleCovMcp.run([]) }.not_to raise_error
+
+    expect(mcp_server_instance).to have_received(:run)
+  end
+end

data/spec/mcp_server_spec.rb

@@ -23,6 +23,7 @@ RSpec.describe SimpleCovMcp::MCPServer do
         attr_accessor :last_instance
       end
       attr_reader :params
+
       def initialize(name:, version:, tools:)
         @params = { name: name, version: version, tools: tools }
         self.class.last_instance = self
@@ -40,14 +41,17 @@ RSpec.describe SimpleCovMcp::MCPServer do
         attr_accessor :last_instance
       end
       attr_reader :server, :opened
+
       def initialize(server)
         @server = server
         @opened = false
         self.class.last_instance = self
       end
+
       def open
         @opened = true
       end
+
       def opened?
         @opened
       end
@@ -56,12 +60,18 @@ RSpec.describe SimpleCovMcp::MCPServer do
     stub_const('MCP::Server', fake_server_class)
     stub_const('MCP::Server::Transports::StdioTransport', fake_transport_class)
 
-    server = described_class.new
-    # Error handler should be set for MCP server usage (factory selection).
-    expect(SimpleCovMcp.error_handler).to be_a(SimpleCovMcp::ErrorHandler)
+    server_context = SimpleCovMcp.create_context(
+      error_handler: SimpleCovMcp::ErrorHandlerFactory.for_mcp_server,
+      log_target: 'stderr'
+    )
+    server = described_class.new(context: server_context)
+    baseline_context = SimpleCovMcp.context
 
     # Run should construct server and open transport
     server.run
+    # Server should restore the caller's context after execution.
+    expect(SimpleCovMcp.context).to eq(baseline_context)
+
     # Fetch the instances created during `run` via the class-level hooks.
     fake_server = fake_server_class.last_instance
     fake_transport = fake_transport_class.last_instance
@@ -73,6 +83,7 @@ RSpec.describe SimpleCovMcp::MCPServer do
     expect(fake_server.params[:name]).to eq('simplecov-mcp')
     # Ensure expected tools are registered
     tool_names = fake_server.params[:tools].map { |t| t.name.split('::').last }
-    expect(tool_names).to include('AllFilesCoverageTool', 'CoverageDetailedTool', 'CoverageRawTool', 'CoverageSummaryTool', 'UncoveredLinesTool', 'HelpTool')
+    expect(tool_names).to include('AllFilesCoverageTool', 'CoverageDetailedTool',
+      'CoverageRawTool', 'CoverageSummaryTool', 'UncoveredLinesTool', 'HelpTool')
   end
 end

data/spec/mode_detector_spec.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::ModeDetector do
+  describe '.cli_mode?' do
+    # Array-driven test cases for comprehensive coverage
+    # Format: [argv, tty?, expected_result, description]
+    CLI_MODE_SCENARIOS = [
+      # Priority 1: --force-cli flag (highest priority)
+      [['--force-cli'], false, true, '--force-cli with piped input'],
+      [['--force-cli', '--json'], false, true, '--force-cli with other flags'],
+
+      # Priority 2: Valid subcommands (must be first arg)
+      [['list'], false, true, 'list subcommand'],
+      [['summary', 'lib/foo.rb'], false, true, 'summary with path'],
+      [['version'], false, true, 'version subcommand'],
+      [['list', '--json'], false, true, 'subcommand with trailing flags'],
+
+      # Priority 3: Invalid subcommand attempts (must be first non-flag arg)
+      [['invalid-command'], false, true, 'invalid subcommand (shows error)'],
+      [['lib/foo.rb'], false, true, 'file path (shows error)'],
+
+      # Priority 4: TTY determines mode when no subcommand/force-cli
+      [[], true, true, 'empty args with TTY'],
+      [[], false, false, 'empty args with piped input'],
+      [['--json'], true, true, 'flags only with TTY'],
+      [['--json'], false, false, 'flags only with piped input'],
+      [['-r', 'foo', '--json'], false, false, 'multiple flags with piped input'],
+
+      # Edge cases: flags before subcommands should now be detected as CLI mode
+      [['--json', 'list'], false, true, 'flag first = CLI mode'],
+      [['-r', 'foo', 'summary'], false, true, 'option first = CLI mode'],
+    ].freeze
+
+    CLI_MODE_SCENARIOS.each do |argv, is_tty, expected, description|
+      it "#{expected ? 'CLI' : 'MCP'}: #{description}" do
+        stdin = double('stdin', tty?: is_tty)
+        result = described_class.cli_mode?(argv, stdin: stdin)
+        expect(result).to be(expected),
+          "Expected cli_mode?(#{argv.inspect}, tty: #{is_tty}) to be #{expected}, got #{result}"
+      end
+    end
+
+    # Test all subcommands dynamically
+    context 'with all valid subcommands' do
+      SimpleCovMcp::ModeDetector::SUBCOMMANDS.each do |subcommand|
+        it "CLI mode for '#{subcommand}' (no TTY)" do
+          stdin = double('stdin', tty?: false)
+          expect(described_class.cli_mode?([subcommand], stdin: stdin)).to be true
+        end
+      end
+    end
+
+    it 'uses STDIN by default when no stdin parameter given' do
+      allow(STDIN).to receive(:tty?).and_return(true)
+      expect(described_class.cli_mode?([])).to be true
+    end
+  end
+
+  describe '.mcp_server_mode?' do
+    # Simpler test cases for the inverse method
+    MCP_SCENARIOS = [
+      [[], false, true, 'piped input, no args'],
+      [['--json'], false, true, 'piped input with flags'],
+      [[], true, false, 'TTY, no args'],
+      [['--force-cli'], false, false, '--force-cli flag'],
+      [['list'], false, false, 'subcommand'],
+    ].freeze
+
+    MCP_SCENARIOS.each do |argv, is_tty, expected, description|
+      it "#{expected ? 'MCP' : 'CLI'}: #{description}" do
+        stdin = double('stdin', tty?: is_tty)
+        expect(described_class.mcp_server_mode?(argv, stdin: stdin)).to be expected
+      end
+    end
+
+    it 'is the logical inverse of cli_mode?' do
+      [[[], true], [[], false], [['list'], false]].each do |argv, is_tty|
+        stdin = double('stdin', tty?: is_tty)
+        cli = described_class.cli_mode?(argv, stdin: stdin)
+        mcp = described_class.mcp_server_mode?(argv, stdin: stdin)
+        expect(mcp).to eq(!cli)
+      end
+    end
+  end
+
+  describe 'priority order' do
+    let(:stdin) { double('stdin', tty?: false) }
+
+    it '1. --force-cli overrides everything' do
+      expect(described_class.cli_mode?(['--force-cli'], stdin: stdin)).to be true
+    end
+
+    it '2. subcommand (first arg) overrides TTY' do
+      expect(described_class.cli_mode?(['list'], stdin: stdin)).to be true
+    end
+
+    it '3. invalid first arg (not flag) triggers CLI' do
+      expect(described_class.cli_mode?(['invalid'], stdin: stdin)).to be true
+    end
+
+    it '4. TTY is checked last (when first arg is flag or empty)' do
+      tty = double('stdin', tty?: true)
+      no_tty = double('stdin', tty?: false)
+
+      expect(described_class.cli_mode?([], stdin: tty)).to be true
+      expect(described_class.cli_mode?([], stdin: no_tty)).to be false
+    end
+  end
+
+  describe 'consistency checks' do
+    it 'SUBCOMMANDS matches CoverageCLI' do
+      expect(SimpleCovMcp::ModeDetector::SUBCOMMANDS).to eq(SimpleCovMcp::CoverageCLI::SUBCOMMANDS)
+    end
+
+    it 'all SUBCOMMANDS are lowercase without dashes' do
+      SimpleCovMcp::ModeDetector::SUBCOMMANDS.each do |cmd|
+        expect(cmd).to eq(cmd.downcase)
+        expect(cmd).not_to start_with('-')
+      end
+    end
+  end
+
+  describe 'regression tests for non-TTY environment' do
+    let(:stdin) { double('stdin', tty?: false) }
+
+    it 'chooses CLI mode for --help' do
+      expect(described_class.cli_mode?(['--help'], stdin: stdin)).to be true
+    end
+
+    it 'chooses CLI mode for -h' do
+      expect(described_class.cli_mode?(['-h'], stdin: stdin)).to be true
+    end
+
+    it 'chooses CLI mode for --version' do
+      expect(described_class.cli_mode?(['--version'], stdin: stdin)).to be true
+    end
+
+    it 'chooses CLI mode for --json list' do
+      expect(described_class.cli_mode?(['--json', 'list'], stdin: stdin)).to be true
+    end
+
+    it 'chooses MCP mode for flags without a subcommand' do
+      expect(described_class.cli_mode?(['--json'], stdin: stdin)).to be false
+    end
+  end
+end

data/spec/model_error_handling_spec.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::CoverageModel, 'error handling' do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+
+  describe 'initialization error handling' do
+    it 'raises CoverageDataError with message detail for invalid JSON format' do
+      # Mock JSON.parse to raise JSON::ParserError
+      allow(JSON).to receive(:parse).and_raise(JSON::ParserError.new('unexpected token'))
+
+      expect do
+        SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
+      end.to raise_error(SimpleCovMcp::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(File).to receive(:read).and_call_original
+      allow(File).to receive(:read).with(end_with('.resultset.json')).and_raise(
+        Errno::EACCES.new('Permission denied')
+      )
+
+      expect do
+        SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
+      end.to raise_error(SimpleCovMcp::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
+      # Create a malformed resultset that will cause TypeError
+      malformed_resultset = {
+        'RSpec' => {
+          'coverage' => 'not_a_hash' # Should be a hash, not a string
+        }
+      }
+
+      allow(File).to receive(:read).and_call_original
+      allow(File).to receive(:read).with(end_with('.resultset.json'))
+        .and_return(malformed_resultset.to_json)
+
+      expect do
+        SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
+      end.to raise_error(SimpleCovMcp::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(:read).and_call_original
+      allow(File).to receive(:read).with(end_with('.resultset.json'))
+        .and_return(malformed_resultset.to_json)
+
+      # This might succeed or fail depending on how the code handles it
+      # Let's make it fail by mocking transform_keys to raise NoMethodError
+      allow_any_instance_of(Hash).to receive(:transform_keys)
+        .and_raise(NoMethodError.new("undefined method `upcase' for nil:NilClass"))
+
+      expect do
+        SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
+      end.to raise_error(SimpleCovMcp::CoverageDataError) do |error|
+        expect(error.message).to include('Invalid coverage data structure')
+      end
+    end
+
+    it 'raises CoverageDataError when path operations raise ArgumentError' do
+      # Create a valid resultset structure with a problematic path
+      valid_resultset = {
+        'RSpec' => {
+          'coverage' => {
+            "lib/foo\x00bar.rb" => { 'lines' => [1, 0, 1] } # Path with NULL byte
+          },
+          'timestamp' => 1000
+        }
+      }
+
+      allow(File).to receive(:read).and_call_original
+      allow(File).to receive(:read).with(end_with('.resultset.json'))
+        .and_return(valid_resultset.to_json)
+
+      # 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
+        SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
+      end.to raise_error(SimpleCovMcp::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
+      # Mock JSON.parse to raise JSON::ParserError with specific message
+      allow(JSON).to receive(:parse).and_raise(
+        JSON::ParserError.new('765: unexpected token at line 3, column 5')
+      )
+
+      expect do
+        SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
+      end.to raise_error(SimpleCovMcp::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(File).to receive(:read).and_call_original
+      allow(File).to receive(:read).with(resultset_path).and_raise(
+        Errno::EACCES.new(resultset_path)
+      )
+
+      expect do
+        SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
+      end.to raise_error(SimpleCovMcp::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 in all specific error types' do
+      test_cases = [
+        {
+          error_class: JSON::ParserError,
+          message: 'unexpected character at byte 42',
+          expected_type: SimpleCovMcp::CoverageDataError,
+          expected_content: 'unexpected character at byte 42'
+        },
+        {
+          error_class: Errno::EACCES,
+          message: '/path/to/coverage/.resultset.json',
+          expected_type: SimpleCovMcp::FilePermissionError,
+          expected_content: '/path/to/coverage/.resultset.json'
+        },
+        {
+          error_class: TypeError,
+          message: 'no implicit conversion of String into Integer',
+          expected_type: SimpleCovMcp::CoverageDataError,
+          expected_content: 'no implicit conversion'
+        }
+      ]
+
+      test_cases.each do |test_case|
+        allow(File).to receive(:read).and_call_original
+        allow(File).to receive(:read).with(end_with('.resultset.json')).and_raise(
+          test_case[:error_class].new(test_case[:message])
+        )
+
+        expect do
+          SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
+        end.to raise_error(test_case[:expected_type]) do |error|
+          expect(error.message).to include(test_case[:expected_content])
+        end
+      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(SimpleCovMcp::CovUtil).to receive(:find_resultset).and_raise(
+        RuntimeError.new('Specified resultset not found: /nonexistent/path/.resultset.json')
+      )
+
+      expect do
+        SimpleCovMcp::CoverageModel.new(root: root, resultset: '/nonexistent/path')
+      end.to raise_error(SimpleCovMcp::CoverageDataError) do |error|
+        expect(error.message).to include('Failed to load coverage data')
+        expect(error.message).to include('Specified resultset not found')
+      end
+    end
+
+    it 'handles RuntimeError with generic messages' do
+      # Test RuntimeError with any generic message
+      allow(SimpleCovMcp::CovUtil).to receive(:find_resultset).and_raise(
+        RuntimeError.new('Something went wrong during resultset lookup')
+      )
+
+      expect do
+        SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage')
+      end.to raise_error(SimpleCovMcp::CoverageDataError) do |error|
+        expect(error.message).to include('Failed to load coverage data')
+        expect(error.message).to include('Something went wrong')
+      end
+    end
+  end
+end