cov-loupe 3.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 = CovLoupe.create_context(
+          error_handler: CovLoupe::ErrorHandlerFactory.for_library,
+          log_target: '/invalid/path/that/does/not/exist.log',
+          mode: :library
+        )
+
+        stderr_output = nil
+        CovLoupe.with_context(context) do
+          silence_output do |_stdout, stderr|
+            CovLoupe::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 = CovLoupe.create_context(
+          error_handler: CovLoupe::ErrorHandlerFactory.for_cli,
+          log_target: '/invalid/path/that/does/not/exist.log',
+          mode: :cli
+        )
+
+        stderr_output = nil
+        CovLoupe.with_context(context) do
+          silence_output do |_stdout, stderr|
+            CovLoupe::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 = CovLoupe.create_context(
+          error_handler: CovLoupe::ErrorHandlerFactory.for_mcp_server,
+          log_target: '/invalid/path/that/does/not/exist.log',
+          mode: :mcp
+        )
+
+        stderr_output = nil
+        CovLoupe.with_context(context) do
+          silence_output do |_stdout, stderr|
+            CovLoupe::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 = CovLoupe.create_context(
+            error_handler: CovLoupe::ErrorHandlerFactory.for_library,
+            log_target: log_file,
+            mode: :library
+          )
+
+          stderr_output = nil
+          CovLoupe.with_context(context) do
+            silence_output do |_stdout, stderr|
+              CovLoupe::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 = CovLoupe.create_context(
+        error_handler: CovLoupe::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 = CovLoupe.create_context(
+        error_handler: CovLoupe::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 mode' do
+      context = CovLoupe.create_context(
+        error_handler: CovLoupe::ErrorHandlerFactory.for_mcp_server,
+        mode: :mcp
+      )
+      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(CovLoupe::ModeDetector).to receive(:cli_mode?).and_return(false)
+
+    expect do
+      CovLoupe.run(argv)
+    end.to raise_error(CovLoupe::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 = CovLoupe.active_log_file
+
+    # Mock ModeDetector to force MCP mode
+    allow(CovLoupe::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(CovLoupe::MCPServer, run: true)
+    captured_context = nil
+    allow(CovLoupe::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
+      CovLoupe.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(CovLoupe.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(CovLoupe::MCPServer)
+    allow(CovLoupe::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 { CovLoupe.run([]) }.not_to raise_error
+
+    expect(mcp_server_instance).to have_received(:run)
+  end
+end

data/spec/mcp_server_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'support/fake_mcp'
+
+RSpec.describe CovLoupe::MCPServer do
+  # This spec verifies the MCP server boot path without requiring the real
+  # MCP runtime. We stub the MCP::Server and its stdio transport to capture
+  # constructor parameters and observe that `open` is invoked.
+  it 'sets error handler and boots server with expected tools' do
+    # Prepare fakes for MCP server and transport
+    module ::MCP; end unless defined?(::MCP)
+
+    stub_const('MCP::Server', FakeMCP::Server)
+    stub_const('MCP::Server::Transports::StdioTransport', FakeMCP::StdioTransport)
+
+    server_context = CovLoupe.create_context(
+      error_handler: CovLoupe::ErrorHandlerFactory.for_mcp_server,
+      log_target: 'stderr'
+    )
+    server = described_class.new(context: server_context)
+    baseline_context = CovLoupe.context
+
+    # Run should construct server and open transport
+    server.run
+    # Server should restore the caller's context after execution.
+    expect(CovLoupe.context).to eq(baseline_context)
+
+    # Fetch the instances created during `run` via the class-level hooks.
+    fake_server = FakeMCP::Server.last_instance
+    fake_transport = FakeMCP::StdioTransport.last_instance
+
+    expect(fake_transport).not_to be_nil
+    expect(fake_transport).to be_opened
+    expect(fake_server).not_to be_nil
+
+    expect(fake_server.params[:name]).to eq('cov-loupe')
+    # 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',
+      'CoverageTotalsTool',
+      'UncoveredLinesTool',
+      'CoverageTableTool',
+      'HelpTool',
+      'VersionTool'
+    )
+  end
+
+  describe 'TOOLSET and TOOL_GUIDE consistency' do
+    it 'includes all tools documented in HelpTool TOOL_GUIDE' do
+      # Get tool classes from TOOLSET
+      toolset_classes = described_class::TOOLSET
+
+      # Get tool classes from TOOL_GUIDE
+      tool_guide_classes = CovLoupe::Tools::HelpTool::TOOL_GUIDE.map { |guide| guide[:tool] }
+
+      # Every tool in TOOL_GUIDE should be in TOOLSET
+      tool_guide_classes.each do |tool_class|
+        expect(toolset_classes).to include(tool_class),
+          "Expected TOOLSET to include #{tool_class.name}, but it was missing. " \
+            'Add it to MCPServer::TOOLSET or remove from HelpTool::TOOL_GUIDE.'
+      end
+    end
+
+    it 'has corresponding TOOL_GUIDE entry for all tools (except HelpTool itself)' do
+      toolset_classes = described_class::TOOLSET
+      tool_guide_classes = CovLoupe::Tools::HelpTool::TOOL_GUIDE.map { |guide| guide[:tool] }
+
+      # Every tool in TOOLSET should be in TOOL_GUIDE (except HelpTool which documents itself)
+      toolset_classes.each do |tool_class|
+        # HelpTool doesn't need an entry about itself
+        next if tool_class == CovLoupe::Tools::HelpTool
+
+        expect(tool_guide_classes).to include(tool_class),
+          "Expected TOOL_GUIDE to document #{tool_class.name}, but it was missing. " \
+            'Add documentation for this tool to HelpTool::TOOL_GUIDE.'
+      end
+    end
+
+    it 'registers the expected number of tools' do
+      expect(described_class::TOOLSET.length).to eq(10)
+    end
+
+    it 'registers all tool classes defined in CovLoupe::Tools module' do
+      # This test catches the bug where a tool file is created, required in
+      # cov_loupe.rb, but not added to MCPServer::TOOLSET.
+      #
+      # Get all classes in the Tools module that inherit from BaseTool
+      tool_classes = CovLoupe::Tools.constants
+        .map { |const_name| CovLoupe::Tools.const_get(const_name) }
+        .select { |const| const.is_a?(Class) && const < CovLoupe::BaseTool }
+
+      toolset_classes = described_class::TOOLSET
+
+      tool_classes.each do |tool_class|
+        expect(toolset_classes).to include(tool_class),
+          "Expected TOOLSET to include #{tool_class.name}, but it was missing. " \
+            'The tool class exists in CovLoupe::Tools but is not registered in MCPServer::TOOLSET.'
+      end
+    end
+  end
+end

data/spec/mode_detector_spec.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# 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', '--format', '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'],
+  [['total'], false, true, 'total subcommand'],
+  [['list', '--format', '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'],
+  [['--format', 'json'], true, true, 'flags only with TTY'],
+  [['--format', 'json'], false, false, 'flags only with piped input'],
+  [['-r', 'foo', '--format', 'json'], false, false, 'multiple flags with piped input'],
+
+  # Edge cases: flags before subcommands should now be detected as CLI mode
+  [['--format', 'json', 'list'], false, true, 'flag first = CLI mode'],
+  [['-r', 'foo', 'summary'], false, true, 'option first = CLI mode'],
+].freeze
+
+# Simpler test cases for the inverse method
+MCP_SCENARIOS = [
+  [[], false, true, 'piped input, no args'],
+  [['--format', 'json'], false, true, 'piped input with flags'],
+  [[], true, false, 'TTY, no args'],
+  [['--force-cli'], false, false, '--force-cli flag'],
+  [['list'], false, false, 'subcommand'],
+].freeze
+
+RSpec.describe CovLoupe::ModeDetector do
+  describe '.cli_mode?' do
+    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
+      CovLoupe::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
+    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(CovLoupe::ModeDetector::SUBCOMMANDS).to eq(CovLoupe::CoverageCLI::SUBCOMMANDS)
+    end
+
+    it 'all SUBCOMMANDS are lowercase without dashes' do
+      CovLoupe::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 -v' do
+      expect(described_class.cli_mode?(['-v'], stdin: stdin)).to be true
+    end
+
+    it 'chooses CLI mode for --json list' do
+      expect(described_class.cli_mode?(['--format', 'json', 'list'], stdin: stdin)).to be true
+    end
+
+    it 'chooses MCP mode for flags without a subcommand' do
+      expect(described_class.cli_mode?(['--format', 'json'], stdin: stdin)).to be false
+    end
+  end
+end