simplecov-mcp 0.3.0 → 1.0.0

data/spec/resultset_loader_spec.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'tmpdir'
+
+RSpec.describe SimpleCovMcp::ResultsetLoader do
+  describe '.load' do
+    it 'parses a single suite and returns coverage map and timestamp' do
+      Dir.mktmpdir do |dir|
+        resultset_path = File.join(dir, '.resultset.json')
+        coverage = {
+          File.join(dir, 'lib', 'foo.rb') => { 'lines' => [1, 0, nil, 2] }
+        }
+        data = {
+          'SuiteA' => {
+            'timestamp' => 123,
+            'coverage' => coverage
+          }
+        }
+        File.write(resultset_path, JSON.generate(data))
+
+        result = described_class.load(resultset_path: resultset_path)
+
+        expect(result.coverage_map).to eq(coverage)
+        expect(result.timestamp).to eq(123)
+        expect(result.suite_names).to eq(['SuiteA'])
+      end
+    end
+
+    it 'merges multiple suites and combines coverage' do
+      Dir.mktmpdir do |dir|
+        resultset_path = File.join(dir, '.resultset.json')
+        foo_path = File.join(dir, 'lib', 'foo.rb')
+        bar_path = File.join(dir, 'lib', 'bar.rb')
+
+        data = {
+          'RSpec' => {
+            'timestamp' => 100,
+            'coverage' => {
+              foo_path => { 'lines' => [1, 0, nil, 0] }
+            }
+          },
+          'Cucumber' => {
+            'timestamp' => 200,
+            'coverage' => {
+              foo_path => { 'lines' => [0, 3, nil, 1] },
+              bar_path => { 'lines' => [0, 1, 1] }
+            }
+          }
+        }
+        File.write(resultset_path, JSON.generate(data))
+
+        result = described_class.load(resultset_path: resultset_path)
+        expect(result.coverage_map[foo_path]['lines']).to eq([1, 3, nil, 1])
+        expect(result.coverage_map[bar_path]['lines']).to eq([0, 1, 1])
+        expect(result.timestamp).to eq(200)
+        expect(result.suite_names).to contain_exactly('RSpec', 'Cucumber')
+      end
+    end
+
+    it 'adapts legacy array coverage entries' do
+      Dir.mktmpdir do |dir|
+        resultset_path = File.join(dir, '.resultset.json')
+        foo_path = File.join(dir, 'lib', 'foo.rb')
+        data = {
+          'SuiteA' => {
+            'timestamp' => 50,
+            'coverage' => {
+              foo_path => [1, 0, nil, 2]
+            }
+          }
+        }
+        File.write(resultset_path, JSON.generate(data))
+
+        result = described_class.load(resultset_path: resultset_path)
+        expect(result.coverage_map[foo_path]).to eq('lines' => [1, 0, nil, 2])
+      end
+    end
+
+    it 'raises CoverageDataError when no suites are present' do
+      Dir.mktmpdir do |dir|
+        resultset_path = File.join(dir, '.resultset.json')
+        File.write(resultset_path, '{}')
+
+        expect do
+          described_class.load(resultset_path: resultset_path)
+        end.to raise_error(SimpleCovMcp::CoverageDataError, /No test suite/)
+      end
+    end
+  end
+
+  describe 'SimpleCov loading and logging' do
+    it 'raises CoverageDataError when SimpleCov cannot be required' do
+      singleton = class << described_class; self; end
+      singleton.send(:define_method, :require) do |name|
+        raise LoadError if name == 'simplecov'
+
+        Kernel.require(name)
+      end
+
+      expect do
+        described_class.send(:require_simplecov_for_merge!, '/tmp/resultset.json')
+      end.to raise_error(SimpleCovMcp::CoverageDataError, /Install simplecov/)
+    ensure
+      if singleton.method_defined?(:require)
+        singleton.send(:remove_method, :require)
+      end
+    end
+
+    it 'logs duplicate suite names when merging coverage' do
+      suites = [
+        described_class::SuiteEntry.new(name: 'RSpec', coverage: {}, timestamp: 0),
+        described_class::SuiteEntry.new(name: 'RSpec', coverage: {}, timestamp: 0),
+        described_class::SuiteEntry.new(name: 'Cucumber', coverage: {}, timestamp: 0)
+      ]
+
+      expect(SimpleCovMcp::CovUtil).to receive(:log)
+        .with(include('Merging duplicate coverage suites for RSpec'))
+      described_class.send(:log_duplicate_suite_names, suites)
+    end
+  end
+
+  describe 'timestamp normalization' do
+    it 'handles float timestamps' do
+      value = described_class.send(:normalize_coverage_timestamp, 123.9, nil)
+      expect(value).to eq(123)
+    end
+
+    it 'handles Time objects' do
+      time = Time.at(456)
+      value = described_class.send(:normalize_coverage_timestamp, time, nil)
+      expect(value).to eq(456)
+    end
+
+    it 'parses numeric string timestamps' do
+      value = described_class.send(:normalize_coverage_timestamp, '789.42', nil)
+      expect(value).to eq(789)
+    end
+
+    it 'falls back to created_at when timestamp missing' do
+      value = described_class.send(:normalize_coverage_timestamp, nil, 321)
+      expect(value).to eq(321)
+    end
+
+    it 'logs warning and returns zero for invalid timestamp strings' do
+      messages = []
+      allow(SimpleCovMcp::CovUtil).to receive(:log) { |msg| messages << msg }
+
+      value = described_class.send(:normalize_coverage_timestamp, 'not-a-timestamp', nil)
+
+      expect(value).to eq(0)
+      expect(messages.join).to include('Coverage resultset timestamp could not be parsed')
+      expect(messages.join).to include('not-a-timestamp')
+    end
+
+    it 'logs warning and returns zero for unsupported types' do
+      messages = []
+      allow(SimpleCovMcp::CovUtil).to receive(:log) { |msg| messages << msg }
+
+      value = described_class.send(:normalize_coverage_timestamp, [:invalid], nil)
+
+      expect(value).to eq(0)
+      expect(messages.join).to include('Coverage resultset timestamp could not be parsed')
+      expect(messages.join).to include('[:invalid]')
+    end
+  end
+end

data/spec/shared_examples/README.md

@@ -0,0 +1,115 @@
+# Shared Examples for MCP Tools
+
+This directory contains reusable test patterns for SimpleCov MCP tools.
+
+## File-Based MCP Tools
+
+The `file_based_mcp_tools.rb` shared example provides parameterized testing for MCP tools that follow the same pattern:
+
+- Take a `path` parameter (file to analyze)
+- Call a specific method on `CoverageModel`
+- Return JSON resource with predictable structure
+- Have consistent output filenames
+
+### Usage
+
+Instead of creating separate spec files for each similar tool, add your tool to the `FILE_BASED_TOOL_CONFIGS` hash:
+
+```ruby
+# In spec/shared_examples/file_based_mcp_tools.rb
+your_tool: {
+  tool_class: SimpleCovMcp::Tools::YourTool,
+  model_method: :your_method,
+  expected_keys: ['file', 'your_data'],
+  output_filename: 'your_tool.json',
+  description: 'your tool data',
+  mock_data: {
+    'file' => '/abs/path/lib/foo.rb',
+    'your_data' => { 'key' => 'value' }
+  },
+  additional_validations: ->(data, item) {
+    expect(data['your_data']).to include('key')
+  }
+}
+```
+
+The parameterized test will automatically:
+- ✅ Test basic MCP resource structure
+- ✅ Verify expected JSON keys are present  
+- ✅ Check correct output filename
+- ✅ Run tool-specific validations
+- ✅ Test parameter consistency across tools
+- ✅ Validate JSON structure consistency
+
+### Benefits vs Individual Spec Files
+
+#### Before (Individual Files)
+```ruby
+# spec/your_tool_spec.rb - 25+ lines
+RSpec.describe SimpleCovMcp::Tools::YourTool do
+  let(:server_context) { instance_double('ServerContext').as_null_object }
+  
+  before do
+    setup_mcp_response_stub
+    model = instance_double(SimpleCovMcp::CoverageModel)
+    allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
+    allow(model).to receive(:your_method).with('lib/foo.rb').and_return({
+      'file' => '/abs/path/lib/foo.rb',
+      'your_data' => { 'key' => 'value' }
+    })
+  end
+
+  subject { described_class.call(path: 'lib/foo.rb', server_context: server_context) }
+
+  it_behaves_like 'an MCP tool that returns JSON resource'
+
+  it 'returns your tool data with expected structure' do
+    response = subject
+    data, item = expect_mcp_json_resource(response, expected_keys: ['file', 'your_data'])
+    
+    expect(item['resource']['name']).to eq('your_tool.json')
+    expect(data['your_data']).to include('key')
+  end
+end
+```
+
+#### After (Parameterized)
+```ruby
+# Just add to FILE_BASED_TOOL_CONFIGS - 8 lines
+your_tool: {
+  tool_class: SimpleCovMcp::Tools::YourTool,
+  model_method: :your_method,
+  expected_keys: ['file', 'your_data'], 
+  output_filename: 'your_tool.json',
+  description: 'your tool data',
+  mock_data: { 'file' => '/abs/path/lib/foo.rb', 'your_data' => { 'key' => 'value' } },
+  additional_validations: ->(data, item) { expect(data['your_data']).to include('key') }
+}
+```
+
+### Additional Benefits
+
+1. **Cross-tool consistency testing**: Automatically tests that all tools handle parameters consistently
+2. **Structural validation**: Ensures all tools return properly formed MCP resources  
+3. **Reduced maintenance**: Bug fixes and improvements benefit all tools at once
+4. **Better coverage**: Gets consistency tests you wouldn't write individually
+5. **Enforces patterns**: Encourages consistent tool design
+
+### When NOT to Use This
+
+Don't use the parameterized approach for tools that:
+- Don't follow the file-based pattern (e.g., `AllFilesCoverageTool`, `VersionTool`)
+- Have significantly different parameter signatures
+- Need extensive tool-specific testing that doesn't fit the pattern
+- Are prototypes or experimental tools
+
+For these cases, create individual spec files as needed.
+
+### Current Tools Using This Pattern
+
+- ✅ `CoverageSummaryTool` - File summary data
+- ✅ `CoverageRawTool` - Raw coverage arrays
+- ✅ `UncoveredLinesTool` - Uncovered line numbers
+- ✅ `CoverageDetailedTool` - Line-by-line coverage details
+
+All tested with 13 shared tests plus 6 tool-specific tests = 19 total tests for 4 tools.

data/spec/shared_examples/coverage_presenter_examples.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'a coverage presenter' do |config|
+  subject(:presenter) { described_class.new(model: model, path: config.fetch(:path, 'lib/foo.rb')) }
+
+  let(:model) { instance_double(SimpleCovMcp::CoverageModel) }
+  let(:raw_payload) { config.fetch(:payload) }
+  let(:stale_value) { config.fetch(:stale) }
+  let(:relative_path) { config.fetch(:relative_path, 'lib/foo.rb') }
+
+  before do
+    allow(model).to receive(config.fetch(:model_method)).with(config.fetch(:path,
+      'lib/foo.rb')).and_return(raw_payload)
+    allow(model).to receive(:staleness_for).with(config.fetch(:path,
+      'lib/foo.rb')).and_return(stale_value)
+    allow(model).to receive(:relativize) do |payload|
+      payload.merge('file' => relative_path)
+    end
+  end
+
+  describe '#absolute_payload' do
+    it 'returns data with stale metadata' do
+      result = presenter.absolute_payload
+
+      expect(result).to include('file' => raw_payload['file'])
+      Array(config.fetch(:expected_keys)).each do |key|
+        expect(result).to include(key => raw_payload[key])
+      end
+      expect(result['stale']).to eq(stale_value)
+    end
+
+    it 'does not mutate the underlying model data' do
+      presenter.absolute_payload
+      expect(raw_payload).not_to have_key('stale')
+    end
+  end
+
+  describe '#relativized_payload' do
+    it 'relativizes the payload once data is loaded' do
+      result = presenter.relativized_payload
+      expect(result['file']).to eq(relative_path)
+      expect(result['stale']).to eq(stale_value)
+    end
+
+    it 'only fetches model data once across calls' do
+      presenter.absolute_payload
+      presenter.relativized_payload
+      expect(model).to have_received(config.fetch(:model_method)).once
+      expect(model).to have_received(:staleness_for).once
+    end
+  end
+
+  describe '#relative_path' do
+    it 'returns the relativized path' do
+      expect(presenter.relative_path).to eq(relative_path)
+    end
+  end
+
+  describe '#stale' do
+    it 'returns the cached staleness flag' do
+      expect(presenter.stale).to eq(stale_value)
+      presenter.relativized_payload
+      expect(presenter.stale).to eq(stale_value)
+    end
+  end
+end

data/spec/shared_examples/file_based_mcp_tools.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# Shared examples for file-based MCP tools that follow the same pattern:
+# - Take a path parameter
+# - Call a specific method on CoverageModel
+# - Return JSON resource with consistent structure
+# - Have predictable output filename
+
+RSpec.shared_examples 'a file-based MCP tool' do |config|
+  let(:server_context) { instance_double('ServerContext').as_null_object }
+  let(:tool_class) { config[:tool_class] }
+  let(:model_method) { config[:model_method] }
+  let(:expected_keys) { config[:expected_keys] }
+  let(:output_filename) { config[:output_filename] }
+  let(:mock_data) { config[:mock_data] }
+  let(:additional_validations) { config[:additional_validations] }
+
+  before do
+    setup_mcp_response_stub
+    model = instance_double(SimpleCovMcp::CoverageModel)
+    allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
+    allow(model).to receive(model_method).with('lib/foo.rb').and_return(mock_data)
+    relativizer = SimpleCovMcp::PathRelativizer.new(
+      root: '/abs/path',
+      scalar_keys: %w[file file_path],
+      array_keys: %w[newer_files missing_files deleted_files]
+    )
+    allow(model).to receive(:relativize) { |payload| relativizer.relativize(payload) }
+    allow(model).to receive(:staleness_for).with('lib/foo.rb').and_return(false)
+  end
+
+  subject { tool_class.call(path: 'lib/foo.rb', server_context: server_context) }
+
+  it_behaves_like 'an MCP tool that returns text JSON'
+
+  it "returns #{config[:description]} with expected structure" do
+    response = subject
+    data, item = expect_mcp_text_json(response, expected_keys: expected_keys)
+
+    if data.is_a?(Hash) && data.key?('file')
+      expect(data['file']).to eq('lib/foo.rb')
+    end
+
+    expect(data).to have_key('stale')
+    expect(data['stale']).to eq(false)
+
+    # Run tool-specific validations if provided
+    if additional_validations
+      instance_exec(data, item, &additional_validations)
+    end
+  end
+
+  # Generate tool-specific examples dynamically
+  tool_specific_examples = config[:tool_specific_examples] || {}
+  tool_specific_examples.each do |example_name, example_block|
+    it example_name do
+      instance_exec(config, &example_block)
+    end
+  end
+end
+
+# Configuration data for each file-based MCP tool
+FILE_BASED_TOOL_CONFIGS = {
+  summary: {
+    tool_class: SimpleCovMcp::Tools::CoverageSummaryTool,
+    model_method: :summary_for,
+    expected_keys: ['file', 'summary', 'stale'],
+    output_filename: 'coverage_summary.json',
+    description: 'coverage summary data',
+    mock_data: {
+      'file' => '/abs/path/lib/foo.rb',
+      'summary' => { 'covered' => 10, 'total' => 12, 'pct' => 83.33 }
+    },
+    additional_validations: ->(data, item) {
+      expect(data['summary']).to include('covered', 'total', 'pct')
+    },
+    tool_specific_examples: {
+      'includes percentage in summary data' => ->(config) {
+        model = instance_double(SimpleCovMcp::CoverageModel)
+        allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
+        allow(model).to receive(:summary_for).and_return(config[:mock_data])
+        allow(model).to receive(:staleness_for).and_return(false)
+        relativizer = SimpleCovMcp::PathRelativizer.new(
+          root: '/abs/path',
+          scalar_keys: %w[file file_path],
+          array_keys: %w[newer_files missing_files deleted_files]
+        )
+        allow(model).to receive(:relativize) { |payload| relativizer.relativize(payload) }
+        setup_mcp_response_stub
+
+        response = config[:tool_class].call(path: 'lib/foo.rb',
+          server_context: instance_double('ServerContext').as_null_object)
+        data, _ = expect_mcp_text_json(response)
+
+        expect(data['summary']['pct']).to be_a(Float)
+      }
+    }
+  },
+
+  raw: {
+    tool_class: SimpleCovMcp::Tools::CoverageRawTool,
+    model_method: :raw_for,
+    expected_keys: ['file', 'lines', 'stale'],
+    output_filename: 'coverage_raw.json',
+    description: 'raw coverage data',
+    mock_data: {
+      'file' => '/abs/path/lib/foo.rb',
+      'lines' => [nil, 1, 0]
+    },
+    additional_validations: ->(data, _item) {
+      expect(data['lines']).to be_an(Array)
+    }
+  },
+
+  uncovered: {
+    tool_class: SimpleCovMcp::Tools::UncoveredLinesTool,
+    model_method: :uncovered_for,
+    expected_keys: ['file', 'uncovered', 'summary', 'stale'],
+    output_filename: 'uncovered_lines.json',
+    description: 'uncovered lines data',
+    mock_data: {
+      'file' => '/abs/path/lib/foo.rb',
+      'uncovered' => [5, 9, 12],
+      'summary' => { 'covered' => 10, 'total' => 12, 'pct' => 83.33 }
+    },
+    additional_validations: ->(data, item) {
+      expect(data['uncovered']).to eq([5, 9, 12])
+    },
+    tool_specific_examples: {
+      'includes both uncovered lines and summary' => ->(config) {
+        model = instance_double(SimpleCovMcp::CoverageModel)
+        allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
+        allow(model).to receive(:uncovered_for).and_return(config[:mock_data])
+        allow(model).to receive(:staleness_for).and_return(false)
+        relativizer = SimpleCovMcp::PathRelativizer.new(
+          root: '/abs/path',
+          scalar_keys: %w[file file_path],
+          array_keys: %w[newer_files missing_files deleted_files]
+        )
+        allow(model).to receive(:relativize) { |payload| relativizer.relativize(payload) }
+        setup_mcp_response_stub
+
+        response = config[:tool_class].call(path: 'lib/foo.rb',
+          server_context: instance_double('ServerContext').as_null_object)
+        data, _ = expect_mcp_text_json(response)
+
+        expect(data['uncovered']).to be_an(Array)
+        expect(data['summary']).to include('covered', 'total', 'pct')
+      }
+    }
+  },
+
+  detailed: {
+    tool_class: SimpleCovMcp::Tools::CoverageDetailedTool,
+    model_method: :detailed_for,
+    expected_keys: ['file', 'lines', 'summary', 'stale'],
+    output_filename: 'coverage_detailed.json',
+    description: 'detailed coverage data',
+    mock_data: {
+      'file' => '/abs/path/lib/foo.rb',
+      'lines' => [
+        { 'line' => 1, 'hits' => 1, 'covered' => true },
+        { 'line' => 2, 'hits' => 0, 'covered' => false }
+      ],
+      'summary' => { 'covered' => 1, 'total' => 2, 'pct' => 50.0 }
+    },
+    additional_validations: ->(data, item) {
+      expect(data['lines']).to be_an(Array)
+      expect(data['lines'].first).to include('line', 'hits', 'covered')
+    }
+  }
+}.freeze

data/spec/shared_examples/mcp_tool_text_json_response.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'an MCP tool that returns text JSON' do
+  let(:server_context) { instance_double('ServerContext').as_null_object }
+
+  before do
+    setup_mcp_response_stub
+  end
+
+  it 'returns a properly structured MCP text JSON response' do
+    response = subject
+    expect_mcp_text_json(response)
+  end
+end

data/spec/simple_cov_mcp_module_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp do
+  # Mode detection tests moved to mode_detector_spec.rb
+  # These tests verify the integration with ModeDetector
+  describe 'mode detection integration' do
+    it 'uses ModeDetector for CLI mode detection' do
+      expect(SimpleCovMcp::ModeDetector).to receive(:cli_mode?).with(['--force-cli'])
+        .and_return(true)
+      expect(SimpleCovMcp::CoverageCLI).to receive_message_chain(:new, :run)
+      SimpleCovMcp.run(['--force-cli'])
+    end
+  end
+end