simplecov-mcp 0.3.0 → 1.0.0

data/spec/tools_error_handling_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'simplecov_mcp/tools/help_tool'
+require 'simplecov_mcp/tools/version_tool'
+require 'simplecov_mcp/tools/coverage_summary_tool'
+require 'simplecov_mcp/tools/coverage_raw_tool'
+require 'simplecov_mcp/tools/uncovered_lines_tool'
+require 'simplecov_mcp/tools/coverage_detailed_tool'
+
+RSpec.describe 'MCP Tool error handling' do
+  let(:server_context) { instance_double('ServerContext').as_null_object }
+
+  before do
+    setup_mcp_response_stub
+  end
+
+  # Note: VersionTool error handling is difficult to test because the tool is so simple
+  # and doesn't have any complex logic that could fail. The rescue clause in the tool
+  # exists for consistency with other tools but is unlikely to be triggered in practice.
+
+  describe SimpleCovMcp::Tools::HelpTool do
+    it 'handles errors during query processing' do
+      # Simulate an error during filter_entries
+      allow(described_class).to receive(:filter_entries).and_raise(StandardError, 'Filter error')
+
+      response = described_class.call(query: 'test', error_mode: 'on',
+        server_context: server_context)
+
+      # Should return error response
+      expect(response).to be_a(MCP::Tool::Response)
+      item = response.payload.first
+      expect(item[:type] || item['type']).to eq('text')
+      expect(item[:text] || item['text']).to include('Error')
+    end
+
+    it 'returns empty array when tokens are empty after filtering' do
+      # Test the edge case where query contains only non-word characters
+      response = described_class.call(query: '!!!', server_context: server_context)
+
+      data = JSON.parse(response.payload.first['text'])
+      # With empty tokens, should return all entries (no filtering applied)
+      expect(data['tools']).not_to be_empty
+    end
+
+    it 'handles non-string, non-array values in filter' do
+      # Test value_matches? with values that are neither strings nor arrays
+      # This exercises the 'else false' branch
+      allow(described_class).to receive(:format_entry).and_return({
+        'tool' => 'test_tool',
+        'label' => nil, # Neither string nor array
+        'use_when' => 123, # Neither string nor array
+        'avoid_when' => true, # Neither string nor array
+        'inputs' => {}, # Neither string nor array
+        'example' => 'example'
+      })
+
+      response = described_class.call(query: 'test', server_context: server_context)
+
+      # Should not crash, should return response
+      expect(response).to be_a(MCP::Tool::Response)
+      data = JSON.parse(response.payload.first['text'])
+      expect(data).to have_key('tools')
+    end
+  end
+
+  describe SimpleCovMcp::Tools::CoverageSummaryTool do
+    it 'handles errors during model creation' do
+      allow(SimpleCovMcp::CoverageModel).to receive(:new).and_raise(StandardError, 'Model error')
+
+      response = described_class.call(
+        path: 'lib/foo.rb',
+        error_mode: 'on',
+        server_context: server_context
+      )
+
+      # Should return error response
+      expect(response).to be_a(MCP::Tool::Response)
+      item = response.payload.first
+      expect(item[:type] || item['type']).to eq('text')
+      expect(item[:text] || item['text']).to include('Error')
+    end
+  end
+
+  describe SimpleCovMcp::Tools::CoverageRawTool do
+    it 'handles errors during raw data retrieval' do
+      model = instance_double(SimpleCovMcp::CoverageModel)
+      allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
+      allow(model).to receive(:raw_for).and_raise(StandardError, 'Raw data error')
+
+      response = SimpleCovMcp::Tools::CoverageRawTool.call(
+        path: 'lib/foo.rb',
+        error_mode: 'on',
+        server_context: server_context
+      )
+
+      # Should return error response
+      expect(response).to be_a(MCP::Tool::Response)
+      item = response.payload.first
+      expect(item[:type] || item['type']).to eq('text')
+      expect(item[:text] || item['text']).to include('Error')
+    end
+  end
+
+  describe SimpleCovMcp::Tools::UncoveredLinesTool do
+    it 'handles errors during uncovered lines retrieval' do
+      model = instance_double(SimpleCovMcp::CoverageModel)
+      allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
+      allow(model).to receive(:uncovered_for).and_raise(StandardError, 'Uncovered error')
+
+      response = SimpleCovMcp::Tools::UncoveredLinesTool.call(
+        path: 'lib/foo.rb',
+        error_mode: 'on',
+        server_context: server_context
+      )
+
+      # Should return error response
+      expect(response).to be_a(MCP::Tool::Response)
+      item = response.payload.first
+      expect(item[:type] || item['type']).to eq('text')
+      expect(item[:text] || item['text']).to include('Error')
+    end
+  end
+
+  describe SimpleCovMcp::Tools::CoverageDetailedTool do
+    it 'handles errors during detailed data retrieval' do
+      model = instance_double(SimpleCovMcp::CoverageModel)
+      allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
+      allow(model).to receive(:detailed_for).and_raise(StandardError, 'Detailed error')
+
+      response = SimpleCovMcp::Tools::CoverageDetailedTool.call(
+        path: 'lib/foo.rb',
+        error_mode: 'on',
+        server_context: server_context
+      )
+
+      # Should return error response
+      expect(response).to be_a(MCP::Tool::Response)
+      item = response.payload.first
+      expect(item[:type] || item['type']).to eq('text')
+      expect(item[:text] || item['text']).to include('Error')
+    end
+  end
+end

data/spec/util_spec.rb

@@ -1,28 +1,15 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'tempfile'
 
 RSpec.describe SimpleCovMcp::CovUtil do
-  let(:root) { (FIXTURES / 'project1').to_s }
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
   let(:resultset_file) { File.join(root, 'coverage', '.resultset.json') }
 
-  it 'latest_timestamp returns integer from fixture' do
-    ts = described_class.latest_timestamp(root, resultset: 'coverage')
-    expect(ts).to be_a(Integer)
-    expect(ts).to eq(1_720_000_000)
-  end
 
-  it 'find_resultset honors SIMPLECOV_RESULTSET file path' do
-    begin
-      ENV['SIMPLECOV_RESULTSET'] = resultset_file
-      path = described_class.find_resultset(root)
-      expect(path).to eq(File.absolute_path(resultset_file, root))
-    ensure
-      ENV.delete('SIMPLECOV_RESULTSET')
-    end
-  end
 
-  it 'lookup_lines supports cwd-stripping and basename fallbacks' do
+  it 'lookup_lines supports cwd-stripping' do
     lines = [1, 0]
 
     # Exact key
@@ -30,29 +17,29 @@ RSpec.describe SimpleCovMcp::CovUtil do
     expect(described_class.lookup_lines(cov, '/abs/path/foo.rb')).to eq(lines)
 
     # CWD strip fallback
-    begin
-      allow(Dir).to receive(:pwd).and_return('/cwd')
-      cov = { 'sub/foo.rb' => { 'lines' => lines } }
-      expect(described_class.lookup_lines(cov, '/cwd/sub/foo.rb')).to eq(lines)
-    ensure
-      # no-op
-    end
+    allow(Dir).to receive(:pwd).and_return('/cwd')
+    cov = { 'sub/foo.rb' => { 'lines' => lines } }
+    expect(described_class.lookup_lines(cov, '/cwd/sub/foo.rb')).to eq(lines)
 
-    # Basename fallback
+    # Different paths with same basename should not match
     cov = { '/some/where/else/foo.rb' => { 'lines' => lines } }
-    expect(described_class.lookup_lines(cov, '/another/place/foo.rb')).to eq(lines)
+    expect do
+      described_class.lookup_lines(cov, '/another/place/foo.rb')
+    end.to raise_error(SimpleCovMcp::FileError, /No coverage entry found/)
 
-    # Missing raises a helpful string error
+    # Missing raises a FileError
     cov = {}
-    expect {
+    expect do
       described_class.lookup_lines(cov, '/nowhere/foo.rb')
-    }.to raise_error(RuntimeError, /No coverage entry found/)
+    end.to raise_error(SimpleCovMcp::FileError, /No coverage entry found/)
   end
 
   it 'summary handles edge cases and coercion' do
     expect(described_class.summary([])).to include('pct' => 100.0, 'total' => 0, 'covered' => 0)
-    expect(described_class.summary([nil, nil])).to include('pct' => 100.0, 'total' => 0, 'covered' => 0)
-    expect(described_class.summary(['1', '0', nil])).to include('pct' => 50.0, 'total' => 2, 'covered' => 1)
+    expect(described_class.summary([nil, nil]))
+      .to include('pct' => 100.0, 'total' => 0, 'covered' => 0)
+    expect(described_class.summary(['1', '0', nil]))
+      .to include('pct' => 50.0, 'total' => 2, 'covered' => 1)
   end
 
   it 'uncovered and detailed ignore nils' do
@@ -65,14 +52,102 @@ RSpec.describe SimpleCovMcp::CovUtil do
     ])
   end
 
-  it 'load_latest_coverage raises CoverageDataError on invalid JSON via model' do
+  it 'load_coverage raises CoverageDataError on invalid JSON via model' do
     Dir.mktmpdir do |dir|
       bad = File.join(dir, '.resultset.json')
       File.write(bad, '{not-json')
-      expect {
+      expect do
         SimpleCovMcp::CoverageModel.new(root: root, resultset: dir)
-      }.to raise_error(SimpleCovMcp::CoverageDataError, /Invalid coverage data format/)
+      end.to raise_error(SimpleCovMcp::CoverageDataError, /Invalid coverage data format/)
     end
   end
-end
 
+  describe 'logging configuration' do
+    let(:test_message) { 'test log message' }
+
+    around(:each) do |example|
+      # Reset logging settings so each example starts clean.
+      old_default = SimpleCovMcp.default_log_file
+      old_active = SimpleCovMcp.active_log_file
+      SimpleCovMcp.default_log_file = nil
+      SimpleCovMcp.active_log_file = nil
+
+      example.run
+
+      # Restore state
+      SimpleCovMcp.default_log_file = old_default
+      SimpleCovMcp.active_log_file = old_active
+    end
+
+
+
+    it "logs to stdout when active_log_file is 'stdout'" do
+      SimpleCovMcp.active_log_file = 'stdout'
+      expect(File).not_to receive(:open)
+      expect { described_class.log(test_message) }
+        .to output(/#{Regexp.escape(test_message)}/).to_stdout
+    end
+
+    it "logs to stderr when active_log_file is 'stderr'" do
+      SimpleCovMcp.active_log_file = 'stderr'
+      expect(File).not_to receive(:open)
+      expect { described_class.log(test_message) }
+        .to output(/#{Regexp.escape(test_message)}/).to_stderr
+    end
+
+    it 'log writes to file when path is configured' do
+      tmp = Tempfile.new('simplecov_mcp-log')
+      log_path = tmp.path
+      tmp.close
+
+      SimpleCovMcp.active_log_file = log_path
+
+      described_class.log(test_message)
+
+      expect(File.exist?(log_path)).to be true
+      content = File.read(log_path)
+      expect(content).to include(test_message)
+      expect(content).to match(TIMESTAMP_REGEX)
+    ensure
+      tmp&.unlink
+    end
+
+    it 'log respects runtime changes disabling logging mid-run' do
+      tmp = Tempfile.new('simplecov_mcp-log')
+      log_path = tmp.path
+      tmp.close
+
+      SimpleCovMcp.active_log_file = log_path
+
+      described_class.log('first entry')
+      expect(File.exist?(log_path)).to be true
+      first_content = File.read(log_path)
+      expect(first_content).to include('first entry')
+
+      SimpleCovMcp.active_log_file = 'stderr'
+
+      expect { described_class.log('second entry') }
+        .to output(/second entry/).to_stderr
+      expect(File.exist?(log_path)).to be true
+      expect(File.read(log_path)).to eq(first_content)
+    ensure
+      tmp&.unlink
+    end
+
+    it 'exposes default log file configuration separately' do
+      original_default = SimpleCovMcp.default_log_file
+      SimpleCovMcp.default_log_file = 'stderr'
+      expect(SimpleCovMcp.default_log_file).to eq('stderr')
+      expect(SimpleCovMcp.active_log_file).to eq('stderr')
+    ensure
+      SimpleCovMcp.default_log_file = original_default
+    end
+
+    it 'allows adjusting the active log target without touching the default' do
+      original_default = SimpleCovMcp.default_log_file
+      SimpleCovMcp.active_log_file = 'stdout'
+      expect(SimpleCovMcp.active_log_file).to eq('stdout')
+      expect(SimpleCovMcp.default_log_file).to eq(original_default)
+    end
+  end
+end

data/spec/version_spec.rb

@@ -2,14 +2,122 @@
 
 require 'spec_helper'
 
-RSpec.describe 'Version constant' do
-  it 'exposes a semver-like version string' do
-    expect(SimpleCovMcp::VERSION).to be_a(String)
-    # Named fragments for readability (simplified SemVer)
-    CORE  = /\d+\.\d+\.\d+/
-    ID    = /[[:alnum:].-]+/            # ASCII alnum plus dot/hyphen
-    SEMVER = /\A#{CORE.source}(?:-#{ID.source})?(?:\+#{ID.source})?\z/
-
-    expect(SimpleCovMcp::VERSION).to match(SEMVER)
+RSpec.describe 'SimpleCovMcp::VERSION' do
+  describe 'constant existence' do
+    it 'defines a VERSION constant' do
+      expect(SimpleCovMcp.const_defined?(:VERSION)).to be true
+    end
+
+    it 'exposes VERSION as a non-empty string' do
+      expect(SimpleCovMcp::VERSION).to be_a(String)
+      expect(SimpleCovMcp::VERSION).not_to be_empty
+    end
+
+    it 'is frozen (immutable)' do
+      expect(SimpleCovMcp::VERSION).to be_frozen
+    end
+  end
+
+  describe 'semantic versioning compliance' do
+    let(:version) { SimpleCovMcp::VERSION }
+    # Simplified semantic versioning regex
+    # Preserves key semver rules: no leading zeros on numeric parts, optional prerelease/build metadata
+    let(:semver_regex) do
+      %r{\A
+        (?<major>0|[1-9]\d*)\.
+        (?<minor>0|[1-9]\d*)\.
+        (?<patch>0|[1-9]\d*)
+        (?:-(?<prerelease>[0-9A-Za-z.-]+))?
+        (?:\+(?<buildmetadata>[0-9A-Za-z.-]+))?
+      \z}x
+    end
+
+    it 'follows semantic versioning format' do
+      expect(version).to match(semver_regex)
+    end
+
+    it 'has valid major.minor.patch core version' do
+      match = version.match(semver_regex)
+      expect(match).not_to be_nil, "VERSION '#{version}' does not match semantic versioning format"
+
+      major = match[:major].to_i
+      minor = match[:minor].to_i
+      patch = match[:patch].to_i
+
+      expect(major).to be >= 0
+      expect(minor).to be >= 0
+      expect(patch).to be >= 0
+    end
+
+    context 'when version has prerelease identifier' do
+      let(:prerelease_version) { '9.9.9-rc.1' }
+
+      before do
+        stub_const('SimpleCovMcp::VERSION', prerelease_version)
+      end
+
+      it 'has valid prerelease format' do
+        match = version.match(semver_regex)
+        prerelease = match[:prerelease]
+        expect(prerelease).not_to be_empty
+        expect(prerelease).not_to start_with('.')
+        expect(prerelease).not_to end_with('.')
+      end
+    end
+
+    context 'when version has build metadata' do
+      let(:build_metadata_version) { '9.9.9+build.42' }
+
+      before do
+        stub_const('SimpleCovMcp::VERSION', build_metadata_version)
+      end
+
+      it 'has valid build metadata format' do
+        match = version.match(semver_regex)
+        buildmetadata = match[:buildmetadata]
+        expect(buildmetadata).not_to be_empty
+        expect(buildmetadata).to match(/\A[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*\z/)
+      end
+    end
+  end
+
+  describe 'version consistency' do
+    it 'is accessible via require path' do
+      expect { SimpleCovMcp::VERSION }.not_to raise_error
+    end
+
+    it 'matches the version referenced in gemspec' do
+      gemspec_path = File.expand_path('../simplecov-mcp.gemspec', __dir__)
+      gemspec_content = File.read(gemspec_path)
+
+      version_line = gemspec_content.lines.find { |line| line.include?('spec.version') }
+      expect(version_line).not_to be_nil, 'Could not find version line in gemspec'
+      expect(version_line).to include('SimpleCovMcp::VERSION')
+    end
+  end
+
+  describe 'current version sanity check' do
+    it 'is not the initial 0.0.0 version' do
+      # Ensure this is a real release, not an uninitialized version
+      expect(SimpleCovMcp::VERSION).not_to eq('0.0.0')
+    end
+  end
+
+  describe 'standalone version file load' do
+    it 'defines the module and VERSION constant when only version.rb is loaded' do
+      original_module = SimpleCovMcp
+      original_version = SimpleCovMcp::VERSION
+
+      Object.send(:remove_const, :SimpleCovMcp)
+
+      version_path = File.expand_path('../lib/simplecov_mcp/version.rb', __dir__)
+      load version_path
+
+      expect(Object.const_defined?(:SimpleCovMcp)).to be true
+      expect(SimpleCovMcp::VERSION).to eq(original_version)
+    ensure
+      Object.send(:remove_const, :SimpleCovMcp) if Object.const_defined?(:SimpleCovMcp)
+      Object.const_set(:SimpleCovMcp, original_module)
+    end
   end
 end

data/spec/version_tool_spec.rb

@@ -1,22 +1,143 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
-require 'simple_cov_mcp/tools/version_tool'
+require 'simplecov_mcp/tools/version_tool'
 
 RSpec.describe SimpleCovMcp::Tools::VersionTool do
   let(:server_context) { instance_double('ServerContext').as_null_object }
 
   before do
-    stub_const('MCP::Tool::Response', Struct.new(:payload))
+    setup_mcp_response_stub
   end
 
-  it 'returns a text payload with the version string' do
-    response = described_class.call(server_context: server_context)
-    item = response.payload.first
-    expect(item[:type] || item['type']).to eq('text')
-    text = item[:text] || item['text']
-    expect(text).to include('SimpleCovMcp version:')
-    expect(text).to include(SimpleCovMcp::VERSION)
+  describe '.call' do
+    it 'returns a text payload with the version string when called without arguments' do
+      response = described_class.call(server_context: server_context)
+      item = response.payload.first
+      expect(item[:type] || item['type']).to eq('text')
+      text = item[:text] || item['text']
+      expect(text).to eq("SimpleCovMcp version: #{SimpleCovMcp::VERSION}")
+    end
+
+    it 'includes the exact version constant value' do
+      response = described_class.call(server_context: server_context)
+      item = response.payload.first
+      text = item[:text] || item['text']
+      expect(text).to include(SimpleCovMcp::VERSION)
+    end
+
+    it 'matches the expected format exactly' do
+      expected_format = "SimpleCovMcp version: #{SimpleCovMcp::VERSION}"
+      response = described_class.call(server_context: server_context)
+      item = response.payload.first
+      text = item[:text] || item['text']
+      expect(text).to eq(expected_format)
+    end
+
+    it 'returns an MCP::Tool::Response object' do
+      response = described_class.call(server_context: server_context)
+      expect(response).to be_a(MCP::Tool::Response)
+    end
+
+    it 'has a single payload item' do
+      response = described_class.call(server_context: server_context)
+      expect(response.payload).to be_an(Array)
+      expect(response.payload.size).to eq(1)
+    end
+
+    context 'when error_mode is specified' do
+      it 'accepts error_mode parameter without affecting output' do
+        response = described_class.call(error_mode: 'off', server_context: server_context)
+        item = response.payload.first
+        text = item[:text] || item['text']
+        expect(text).to eq("SimpleCovMcp version: #{SimpleCovMcp::VERSION}")
+      end
+
+      it 'accepts error_mode "on" (default)' do
+        response = described_class.call(error_mode: 'on', server_context: server_context)
+        item = response.payload.first
+        expect(item[:type] || item['type']).to eq('text')
+      end
+
+      it 'accepts error_mode "trace"' do
+        response = described_class.call(error_mode: 'trace', server_context: server_context)
+        item = response.payload.first
+        expect(item[:type] || item['type']).to eq('text')
+      end
+    end
+
+    context 'when additional arguments are passed' do
+      it 'ignores additional arguments gracefully' do
+        response = described_class.call(
+          server_context: server_context,
+          extra_arg: 'value',
+          another: { nested: 'data' }
+        )
+        item = response.payload.first
+        text = item[:text] || item['text']
+        expect(text).to eq("SimpleCovMcp version: #{SimpleCovMcp::VERSION}")
+      end
+    end
+
+    context 'when an error occurs' do
+      it 'handles VERSION constant access errors and returns structured error response' do
+        # Force an error by overriding const_get to raise an error when VERSION is accessed
+        allow(SimpleCovMcp).to receive(:const_missing).with(:VERSION).and_raise(StandardError,
+          'Version access error')
+
+        # Clear the cached VERSION constant to trigger const_missing
+        SimpleCovMcp.send(:remove_const, :VERSION) if SimpleCovMcp.const_defined?(:VERSION)
+
+        response = described_class.call(error_mode: 'on', server_context: server_context)
+
+        # Should return error response in MCP format
+        expect(response).to be_a(MCP::Tool::Response)
+        item = response.payload.first
+        expect(item[:type] || item['type']).to eq('text')
+
+        error_text = item[:text] || item['text']
+        expect(error_text).to include('Error')
+      end
+
+      it 'handles errors in the response creation process' do
+        # Force an error by mocking string interpolation to fail
+        version_obj = double('VERSION')
+        allow(version_obj).to receive(:to_s).and_raise(StandardError, 'String conversion error')
+
+        # Replace VERSION with our mock object
+        stub_const('SimpleCovMcp::VERSION', version_obj)
+
+        response = described_class.call(error_mode: 'on', server_context: server_context)
+
+        # Should return error response in MCP format via the rescue block
+        expect(response).to be_a(MCP::Tool::Response)
+        item = response.payload.first
+        expect(item[:type] || item['type']).to eq('text')
+
+        error_text = item[:text] || item['text']
+        expect(error_text).to include('Error')
+      end
+
+      it 'respects error_mode setting when handling errors' do
+        # Force an error using a mock VERSION that raises an exception
+        version_obj = double('VERSION')
+        allow(version_obj).to receive(:to_s).and_raise(StandardError, 'Version error')
+        stub_const('SimpleCovMcp::VERSION', version_obj)
+
+        # Test error_mode 'off' (should be silent but still return structured response)
+        response = described_class.call(error_mode: 'off', server_context: server_context)
+        expect(response).to be_a(MCP::Tool::Response)
+        item = response.payload.first
+        expect(item[:type] || item['type']).to eq('text')
+
+        # Test error_mode 'trace' (should include more detail)
+        response = described_class.call(error_mode: 'trace', server_context: server_context)
+        expect(response).to be_a(MCP::Tool::Response)
+        item = response.payload.first
+        expect(item[:type] || item['type']).to eq('text')
+        error_text = item[:text] || item['text']
+        expect(error_text).to include('Error')
+      end
+    end
   end
 end
-