simplecov-mcp 1.0.0 → 2.0.0

data/spec/integration_spec.rb

@@ -2,148 +2,74 @@
 
 require 'spec_helper'
 
+# Timeout for MCP server operations (increased for JRuby compatibility)
+MCP_TIMEOUT = 5
+
 RSpec.describe 'SimpleCov MCP Integration Tests' do
   let(:project_root) { (FIXTURES_DIR / 'project1').to_s }
   let(:coverage_dir) { File.join(project_root, 'coverage') }
   let(:resultset_path) { File.join(coverage_dir, '.resultset.json') }
 
   describe 'End-to-End Coverage Model Functionality' do
-    context 'with real coverage data and files' do
-      it 'provides complete coverage analysis workflow' do
-        # Initialize model with real fixture data
-        model = SimpleCovMcp::CoverageModel.new(root: project_root, resultset: coverage_dir)
-
-        # Test all_files returns real coverage data
-        all_files = model.all_files
-        expect(all_files).to be_an(Array)
-        expect(all_files.length).to eq(2)
-
-        # Verify file paths and coverage data structure
-        foo_file = all_files.find { |f| f['file'].include?('foo.rb') }
-        bar_file = all_files.find { |f| f['file'].include?('bar.rb') }
-
-        expect(foo_file).to include('covered', 'total', 'percentage', 'stale')
-        expect(bar_file).to include('covered', 'total', 'percentage', 'stale')
-
-        # Verify actual coverage calculations match fixture data
-        # foo.rb has coverage: [1, 0, nil, 2] -> 2 covered out of 3 executable = 66.67%
-        expect(foo_file['total']).to eq(3)
-        expect(foo_file['covered']).to eq(2)
-        expect(foo_file['percentage']).to be_within(0.01).of(66.67)
-
-        # bar.rb has coverage: [0, 0, 1] -> 1 covered out of 3 executable = 33.33%
-        expect(bar_file['total']).to eq(3)
-        expect(bar_file['covered']).to eq(1)
-        expect(bar_file['percentage']).to be_within(0.01).of(33.33)
-      end
-
-      it 'provides detailed per-file analysis' do
-        model = SimpleCovMcp::CoverageModel.new(root: project_root, resultset: coverage_dir)
-
-        # Test raw coverage data
-        raw = model.raw_for('lib/foo.rb')
-        expect(raw['file']).to end_with('lib/foo.rb')
-        expect(raw['lines']).to eq([1, 0, nil, 2])
-
-        # Test summary calculation
-        summary = model.summary_for('lib/foo.rb')
-        expect(summary['file']).to end_with('lib/foo.rb')
-        expect(summary['summary']).to include('covered' => 2, 'total' => 3)
-        expect(summary['summary']['pct']).to be_within(0.01).of(66.67)
-
-        # Test uncovered lines detection
-        uncovered = model.uncovered_for('lib/foo.rb')
-        expect(uncovered['file']).to end_with('lib/foo.rb')
-        expect(uncovered['uncovered']).to eq([2]) # Line 2 has 0 hits
-        expect(uncovered['summary']).to include('covered' => 2, 'total' => 3)
-
-        # Test detailed line-by-line analysis
-        detailed = model.detailed_for('lib/foo.rb')
-        expect(detailed['file']).to end_with('lib/foo.rb')
-        expect(detailed['lines']).to eq([
-          { 'line' => 1, 'hits' => 1, 'covered' => true },
-          { 'line' => 2, 'hits' => 0, 'covered' => false },
-          { 'line' => 4, 'hits' => 2, 'covered' => true }
-        ])
-      end
-
-      it 'generates properly formatted coverage tables' do
-        model = SimpleCovMcp::CoverageModel.new(root: project_root, resultset: coverage_dir)
-
-        # Test default table generation
-        table = model.format_table
-
-        # Verify table structure (Unicode box drawing)
-        expect(table).to include('┌', '┬', '┐', '│', '├', '┼', '┤', '└', '┴', '┘')
-
-        # Verify headers
-        expect(table).to include('File', '%', 'Covered', 'Total', 'Stale')
+    it 'loads fixture coverage and surfaces core stats across APIs' do
+      model = SimpleCovMcp::CoverageModel.new(root: project_root, resultset: coverage_dir)
 
-        # Verify file data appears
-        expect(table).to include('lib/foo.rb', 'lib/bar.rb')
+      files = model.all_files
+      expect(files.length).to eq(2)
+      files_by_name = files.to_h { |f| [File.basename(f['file']), f] }
 
-        # Verify percentages are formatted correctly
-        expect(table).to include('66.67', '33.33')
+      foo = files_by_name.fetch('foo.rb')
+      bar = files_by_name.fetch('bar.rb')
+      expect(foo['percentage']).to be_within(0.01).of(66.67)
+      expect(bar['percentage']).to be_within(0.01).of(33.33)
 
-        # Verify counts summary
-        expect(table).to include('Files: total 2')
+      raw = model.raw_for('lib/foo.rb')
+      expect(raw['lines']).to eq([1, 0, nil, 2])
 
-        # Test sorting (ascending by default - bar.rb should be first with lower coverage)
-        lines = table.split("\n")
-        data_lines = lines.select { |line| line.include?('lib/') }
-        expect(data_lines.first).to include('lib/bar.rb') # Lower coverage first
-        expect(data_lines.last).to include('lib/foo.rb')  # Higher coverage last
-      end
+      summary = model.summary_for('lib/foo.rb')
+      expect(summary['summary']).to include('covered' => 2, 'total' => 3)
 
-      it 'supports different sorting options' do
-        model = SimpleCovMcp::CoverageModel.new(root: project_root, resultset: coverage_dir)
+      uncovered = model.uncovered_for('lib/foo.rb')
+      expect(uncovered['uncovered']).to eq([2])
 
-        # Test ascending sort
-        asc_files = model.all_files(sort_order: :ascending)
-        expect(asc_files.first['file']).to end_with('lib/bar.rb')  # Lower coverage first
-        expect(asc_files.last['file']).to end_with('lib/foo.rb')   # Higher coverage last
+      detailed = model.detailed_for('lib/foo.rb')
+      expect(detailed['lines']).to include({ 'line' => 2, 'hits' => 0, 'covered' => false })
 
-        # Test descending sort
-        desc_files = model.all_files(sort_order: :descending)
-        expect(desc_files.first['file']).to end_with('lib/foo.rb') # Higher coverage first
-        expect(desc_files.last['file']).to end_with('lib/bar.rb')  # Lower coverage last
-      end
+      table = model.format_table
+      expect(table).to include('lib/foo.rb', 'lib/bar.rb', '66.67', '33.33')
+      data_lines = table.split("\n").select { |line| line.include?('lib/') }
+      expect(data_lines.first).to include('lib/foo.rb') # Highest coverage first (descending default)
+      expect(data_lines.last).to include('lib/bar.rb')
     end
   end
 
   describe 'CLI Integration with Real Coverage Data' do
     it 'executes all major CLI commands without errors' do
       # Test list command
-      list_output = nil
-      silence_output do |out, _err|
-        cli = SimpleCovMcp::CoverageCLI.new
-        cli.run(['list', '--root', project_root, '--resultset', coverage_dir])
-        list_output = out.string
-      end
-
+      list_output, _err, status = run_cli_with_status('--root', project_root, '--resultset',
+        coverage_dir, 'list')
+      expect(status).to eq(0)
       expect(list_output).to include('lib/foo.rb', 'lib/bar.rb')
       expect(list_output).to include('66.67', '33.33')
+      data_lines = list_output.lines.select { |line| line.include?('lib/') }
+      expect(data_lines.first).to include('lib/foo.rb') # Highest coverage first (descending default)
+      expect(data_lines.last).to include('lib/bar.rb')
 
       # Test summary command
-      summary_output = nil
-      silence_output do |out, _err|
-        cli = SimpleCovMcp::CoverageCLI.new
-        cli.run(['summary', 'lib/foo.rb', '--root', project_root, '--resultset', coverage_dir])
-        summary_output = out.string
-      end
-
-      expect(summary_output).to include('66.67%', '2/3')
+      summary_output, _err, status = run_cli_with_status('--root', project_root, '--resultset',
+        coverage_dir, 'summary', 'lib/foo.rb')
+      expect(status).to eq(0)
+      expect(summary_output).to include('│')  # Table format
+      expect(summary_output).to include('66.67%')
+      expect(summary_output).to include('2')
+      expect(summary_output).to include('3')
 
       # Test JSON output
-      json_output = nil
-      silence_output do |out, _err|
-        cli = SimpleCovMcp::CoverageCLI.new
-        cli.run([
-          'summary', 'lib/foo.rb', '--json', '--root', project_root, '--resultset', coverage_dir
-        ])
-        json_output = out.string
-      end
-
+      json_output, _err, status = run_cli_with_status(
+        '--format', 'json', '--root', project_root, '--resultset', coverage_dir,
+        'summary', 'lib/foo.rb'
+      )
+      expect(status).to eq(0)
       json_data = JSON.parse(json_output)
       expect(json_data).to include('file', 'summary')
       expect(json_data['summary']).to include('covered' => 2, 'total' => 3)
@@ -151,23 +77,17 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
 
     it 'handles different output formats correctly' do
       # Test uncovered command with different outputs
-      uncovered_output = nil
-      silence_output do |out, _err|
-        cli = SimpleCovMcp::CoverageCLI.new
-        cli.run(['uncovered', 'lib/foo.rb', '--root', project_root, '--resultset', coverage_dir])
-        uncovered_output = out.string
-      end
-
-      expect(uncovered_output).to match(/Uncovered lines:\s*2\b/)
+      uncovered_output, _err, status = run_cli_with_status(
+        '--root', project_root, '--resultset', coverage_dir, 'uncovered', 'lib/foo.rb'
+      )
+      expect(status).to eq(0)
+      expect(uncovered_output).to include('│')  # Table format
 
       # Test detailed command
-      detailed_output = nil
-      silence_output do |out, _err|
-        cli = SimpleCovMcp::CoverageCLI.new
-        cli.run(['detailed', 'lib/foo.rb', '--root', project_root, '--resultset', coverage_dir])
-        detailed_output = out.string
-      end
-
+      detailed_output, _err, status = run_cli_with_status(
+        '--root', project_root, '--resultset', coverage_dir, 'detailed', 'lib/foo.rb'
+      )
+      expect(status).to eq(0)
       expect(detailed_output).to include('Line', 'Hits', 'Covered')
     end
   end
@@ -188,7 +108,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
         server_context: server_context
       )
 
-      data, item = expect_mcp_text_json(summary_response, expected_keys: ['file', 'summary'])
+      data, _item = expect_mcp_text_json(summary_response, expected_keys: ['file', 'summary'])
       expect(data['summary']).to include('covered' => 2, 'total' => 3)
 
       # Test raw coverage tool
@@ -199,7 +119,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
         server_context: server_context
       )
 
-      raw_data, raw_item = expect_mcp_text_json(raw_response, expected_keys: ['file', 'lines'])
+      raw_data, _raw_item = expect_mcp_text_json(raw_response, expected_keys: ['file', 'lines'])
       expect(raw_data['lines']).to eq([1, 0, nil, 2])
 
       # Test all files tool
@@ -209,7 +129,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
         server_context: server_context
       )
 
-      all_data, _ = expect_mcp_text_json(all_files_response, expected_keys: ['files', 'counts'])
+      all_data, = expect_mcp_text_json(all_files_response, expected_keys: ['files', 'counts'])
       expect(all_data['files'].length).to eq(2)
       expect(all_data['counts']['total']).to eq(2)
     end
@@ -222,7 +142,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
         resultset: coverage_dir,
         server_context: server_context
       )
-      summary_data, _ = expect_mcp_text_json(summary_response)
+      summary_data, = expect_mcp_text_json(summary_response)
 
       # Get data from detailed tool
       detailed_response = SimpleCovMcp::Tools::CoverageDetailedTool.call(
@@ -231,7 +151,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
         resultset: coverage_dir,
         server_context: server_context
       )
-      detailed_data, _ = expect_mcp_text_json(detailed_response)
+      detailed_data, = expect_mcp_text_json(detailed_response)
 
       # Verify consistency between tools
       expect(summary_data['summary']['covered']).to eq(2)
@@ -257,24 +177,13 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
     it 'handles invalid resultset paths gracefully' do
       expect do
         SimpleCovMcp::CoverageModel.new(root: project_root, resultset: '/nonexistent/path')
-      end.to raise_error(SimpleCovMcp::CoverageDataError, /Failed to load coverage data/)
+      end.to raise_error(SimpleCovMcp::ResultsetNotFoundError, /Specified resultset not found/)
     end
 
     it 'provides helpful CLI error messages' do
-      output, error, status = nil, nil, nil
-      silence_output do |out, err|
-        begin
-          cli = SimpleCovMcp::CoverageCLI.new
-          cli.run([
-            'summary', 'lib/nonexistent.rb', '--root', project_root, '--resultset', coverage_dir
-          ])
-          status = 0
-        rescue SystemExit => e
-          status = e.status
-        end
-        output = out.string
-        error = err.string
-      end
+      _output, error, status = run_cli_with_status(
+        '--root', project_root, '--resultset', coverage_dir, 'summary', 'lib/nonexistent.rb'
+      )
 
       expect(status).to eq(1)
       expect(error).to include('File error:', 'No coverage entry found')
@@ -318,7 +227,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
     let(:default_env) do
       {
         'RUBY_LIB' => lib_path,
-        'SIMPLECOV_MCP_OPTS' => "--root #{project_root} --resultset #{coverage_dir}"
+        'SIMPLECOV_MCP_OPTS' => "--root #{project_root} --resultset #{coverage_dir} --log-file /dev/null"
       }
     end
 
@@ -332,7 +241,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
     end
 
     # Run the MCP executable with a single JSON-RPC request hash and return the captured streams.
-    def run_mcp_json(request_hash, env: default_env, timeout: 5)
+    def run_mcp_json(request_hash, env: default_env, timeout: MCP_TIMEOUT)
       Spec::Support::McpRunner.call_json(
         request_hash,
         **runner_args(env: env, timeout: timeout)
@@ -340,7 +249,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
     end
 
     # Run the MCP executable with a sequence of JSON-RPC requests (one per line).
-    def run_mcp_json_stream(request_hashes, env: default_env, timeout: 5)
+    def run_mcp_json_stream(request_hashes, env: default_env, timeout: MCP_TIMEOUT)
       Spec::Support::McpRunner.call_json_stream(
         request_hashes,
         **runner_args(env: env, timeout: timeout)
@@ -348,7 +257,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
     end
 
     # Run the MCP executable with a raw string payload (already encoded as needed).
-    def run_mcp_input(input, env: default_env, timeout: 5)
+    def run_mcp_input(input, env: default_env, timeout: MCP_TIMEOUT)
       Spec::Support::McpRunner.call(
         input: input,
         **runner_args(env: env, timeout: timeout)
@@ -357,7 +266,9 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
 
     def parse_jsonrpc_response(output)
       # MCP server should only write JSON-RPC responses to stdout.
-      output.lines.each do |line|
+      # Force UTF-8 encoding to handle any binary data in the output stream.
+      safe_output = output.to_s.encode('UTF-8', invalid: :replace, undef: :replace, replace: '')
+      safe_output.lines.each do |line|
         stripped = line.strip
         next if stripped.empty?
 
@@ -559,6 +470,37 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
       expect(version_text).to match(/SimpleCovMcp version: \d+\.\d+/)
     end
 
+    it 'executes validate_tool via JSON-RPC' do
+      request = {
+        jsonrpc: '2.0',
+        id: 80,
+        method: 'tools/call',
+        params: {
+          name: 'validate_tool',
+          arguments: {
+            code: '->(m) { true }',
+            root: project_root,
+            resultset: coverage_dir
+          }
+        }
+      }
+
+      stdout = run_mcp_json(request)[:stdout]
+      response = parse_jsonrpc_response(stdout)
+
+      expect(response['id']).to eq(80)
+      content = response['result']['content']
+      expect(content.first['type']).to eq('text')
+
+      begin
+        result_json = JSON.parse(content.first['text'])
+      rescue JSON::ParserError
+        puts "DEBUG: Failed to parse JSON. Content was: #{content.first['text']}"
+        raise
+      end
+      expect(result_json).to include('result' => true)
+    end
+
     it 'handles error responses for invalid tool calls' do
       request = {
         jsonrpc: '2.0',
@@ -594,7 +536,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
       malformed_request = "{'jsonrpc': '2.0', 'id': 999, 'method': 'invalid'}"
 
       env = { 'RUBY_LIB' => lib_path }
-      result = run_mcp_input(malformed_request, env: env, timeout: 3)
+      result = run_mcp_input(malformed_request, env: env)
 
       # Should handle gracefully without crashing
       # May return error response or empty output
@@ -615,8 +557,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
 
       result = run_mcp_json(
         request,
-        env: default_env.merge('SIMPLECOV_MCP_OPTS' => '--log-file stderr'),
-        timeout: 3
+        env: default_env.merge('SIMPLECOV_MCP_OPTS' => '--log-file stderr')
       )
 
       response = parse_jsonrpc_response(result[:stdout])
@@ -631,7 +572,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
         'SIMPLECOV_MCP_OPTS' => '--log-file stdout'
       }
 
-      result = run_mcp_input(nil, env: env, timeout: 3)
+      result = run_mcp_input(nil, env: env)
 
       combined_output = result[:stdout] + result[:stderr]
       expect(combined_output).to include('stdout').and include('not permitted')
@@ -645,9 +586,12 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
           params: { name: 'version_tool', arguments: {} } }
       ]
 
-      result = run_mcp_json_stream(requests, timeout: 5)
+      result = run_mcp_json_stream(requests)
 
-      responses = result[:stdout].lines.map do |line|
+      # Force UTF-8 encoding to handle any binary data in the output stream
+      safe_stdout = result[:stdout].to_s
+        .encode('UTF-8', invalid: :replace, undef: :replace, replace: '')
+      responses = safe_stdout.lines.map do |line|
         next if line.strip.empty?
 
         begin
@@ -663,7 +607,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
       expect(response_ids).to include(100).or include(101)
     end
 
-    context 'MCP protocol error handling' do
+    context 'when handling MCP protocol errors' do
       it 'returns error for unknown tool name' do
         request = {
           jsonrpc: '2.0',
@@ -695,7 +639,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
           text = content.first['text']
           expect(text.downcase).to include('error').or include('not found')
         else
-          fail 'Expected either error or result field in response'
+          raise 'Expected either error or result field in response'
         end
       end
 
@@ -724,7 +668,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
           text = content.first['text']
           expect(text.downcase).to include('error').or include('required').or include('path')
         else
-          fail 'Expected either error or result field in response'
+          raise 'Expected either error or result field in response'
         end
       end
 
@@ -736,7 +680,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
           params: {
             name: 'coverage_summary_tool',
             arguments: {
-              path: 12345, # Should be string, not number
+              path: 12_345, # Should be string, not number
               root: project_root,
               resultset: coverage_dir
             }
@@ -811,7 +755,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
       it 'handles completely invalid JSON input' do
         invalid_json = 'this is not JSON at all'
 
-        result = run_mcp_input(invalid_json, env: default_env, timeout: 3)
+        result = run_mcp_input(invalid_json, env: default_env)
 
         # Should not crash with unhandled exception
         combined = result[:stdout] + result[:stderr]
@@ -825,7 +769,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
       end
 
       it 'handles empty input gracefully' do
-        result = run_mcp_input('', env: default_env, timeout: 2)
+        result = run_mcp_input('', env: default_env)
 
         # Empty input should be handled without crash
         expect(result[:stderr]).not_to include('NameError')
@@ -835,7 +779,7 @@ RSpec.describe 'SimpleCov MCP Integration Tests' do
       it 'handles partial JSON input' do
         partial_json = '{"jsonrpc": "2.0", "id": 300, "method":'
 
-        result = run_mcp_input(partial_json, env: default_env, timeout: 2)
+        result = run_mcp_input(partial_json, env: default_env)
 
         # Should handle gracefully without crashing
         expect(result[:stderr]).not_to include('uninitialized constant')

data/spec/logging_fallback_spec.rb

@@ -54,7 +54,7 @@ RSpec.describe 'Logging Fallback Behavior' do
         context = SimpleCovMcp.create_context(
           error_handler: SimpleCovMcp::ErrorHandlerFactory.for_mcp_server,
           log_target: '/invalid/path/that/does/not/exist.log',
-          mode: :mcp_server
+          mode: :mcp
         )
 
         stderr_output = nil
@@ -115,10 +115,10 @@ RSpec.describe 'Logging Fallback Behavior' do
       expect(context.mcp_mode?).to be false
     end
 
-    it 'correctly identifies MCP server mode' do
+    it 'correctly identifies MCP mode' do
       context = SimpleCovMcp.create_context(
         error_handler: SimpleCovMcp::ErrorHandlerFactory.for_mcp_server,
-        mode: :mcp_server
+        mode: :mcp
       )
       expect(context.library_mode?).to be false
       expect(context.cli_mode?).to be false

data/spec/mcp_server_integration_spec.rb

@@ -5,7 +5,7 @@ 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)
+    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

data/spec/mcp_server_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'support/fake_mcp'
 
 RSpec.describe SimpleCovMcp::MCPServer do
   # This spec verifies the MCP server boot path without requiring the real
@@ -10,55 +11,8 @@ RSpec.describe SimpleCovMcp::MCPServer do
     # Prepare fakes for MCP server and transport
     module ::MCP; end unless defined?(::MCP)
 
-    # Fake server captures the last created instance so we can assert on the
-    # name/version/tools passed in by SimpleCovMcp::MCPServer. The
-    # `last_instance` accessor is a class-level handle to the most recently
-    # instantiated fake. Because the production code constructs the server
-    # internally, we can't grab the instance directly; recording the most
-    # recent instance lets the test fetch it after `run` completes.
-    fake_server_class = Class.new do
-      class << self
-        # Holds the most recently created fake server instance so tests can
-        # inspect it after the code under test performs internal construction.
-        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
-      end
-    end
-
-    # Fake stdio transport records whether `open` was called and the server
-    # it was initialized with, to confirm that the server was started. It also
-    # exposes a `last_instance` class accessor for the same reason as above:
-    # to retrieve the instance created during `run` so we can assert on it.
-    fake_transport_class = Class.new do
-      class << self
-        # Holds the most recently created fake transport instance for later
-        # assertions (e.g., that `open` was invoked).
-        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
-    end
-
-    stub_const('MCP::Server', fake_server_class)
-    stub_const('MCP::Server::Transports::StdioTransport', fake_transport_class)
+    stub_const('MCP::Server', FakeMCP::Server)
+    stub_const('MCP::Server::Transports::StdioTransport', FakeMCP::StdioTransport)
 
     server_context = SimpleCovMcp.create_context(
       error_handler: SimpleCovMcp::ErrorHandlerFactory.for_mcp_server,
@@ -73,8 +27,8 @@ RSpec.describe SimpleCovMcp::MCPServer do
     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
+    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
@@ -83,7 +37,70 @@ 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',
+      '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 = SimpleCovMcp::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 = SimpleCovMcp::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 == SimpleCovMcp::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 SimpleCovMcp::Tools module' do
+      # This test catches the bug where a tool file is created, required in
+      # simplecov_mcp.rb, but not added to MCPServer::TOOLSET.
+      #
+      # Get all classes in the Tools module that inherit from BaseTool
+      tool_classes = SimpleCovMcp::Tools.constants
+        .map { |const_name| SimpleCovMcp::Tools.const_get(const_name) }
+        .select { |const| const.is_a?(Class) && const < SimpleCovMcp::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 SimpleCovMcp::Tools but is not registered in MCPServer::TOOLSET.'
+      end
+    end
   end
 end