simplecov-mcp 1.0.1 → 2.0.0

data/spec/shared_examples/formatted_command_examples.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'json'
+
+RSpec.shared_examples 'a command with formatted output' do |command_args, expected_json_keys|
+  context 'with json format' do
+    before { cli_context.config.format = :json }
+
+    it 'outputs valid JSON' do
+      output = capture_command_output(command, command_args)
+      json = JSON.parse(output)
+
+      if expected_json_keys.is_a?(Array)
+        expected_json_keys.each { |k| expect(json).to have_key(k) }
+      elsif expected_json_keys.is_a?(Hash)
+        expected_json_keys.each do |k, v|
+          expect(json).to have_key(k)
+          # Skip deep comparison if v is nil, just check key existence
+          expect(json[k]).to eq(v) if v
+        end
+      end
+    end
+  end
+
+  context 'with yaml format' do
+    before { cli_context.config.format = :yaml }
+
+    it 'outputs valid YAML' do
+      output = capture_command_output(command, command_args)
+      # Allow Symbol for keys that might be symbols (e.g. from version command)
+      yaml = YAML.safe_load(output, permitted_classes: [Symbol])
+
+      if expected_json_keys.is_a?(Array)
+        expected_json_keys.each do |k|
+          # Check for string or symbol key
+          expect(yaml).to have_key(k).or have_key(k.to_sym)
+        end
+      elsif expected_json_keys.is_a?(Hash)
+        expected_json_keys.each do |k, v|
+          val = yaml.key?(k) ? yaml[k] : yaml[k.to_sym]
+          expect(val).not_to be_nil
+          expect(val).to eq(v) if v
+        end
+      end
+    end
+  end
+
+  context 'with awesome_print format' do
+    before { cli_context.config.format = :awesome_print }
+
+    it 'outputs awesome_print formatted string' do
+      output = capture_command_output(command, command_args)
+      # Strip ANSI color codes for matching
+      plain_output = output.gsub(/\e\[([;\d]+)?m/, '')
+
+      keys_to_check = expected_json_keys.is_a?(Hash) ? expected_json_keys.keys : expected_json_keys
+      keys_to_check.each do |k|
+        # Check for string key "key" => or symbol key :key =>
+        expect(plain_output).to match(/"#{k}"\s*=>|:#{k}\s*=>/)
+      end
+    end
+  end
+end

data/spec/simple_cov_mcp_module_spec.rb

@@ -7,10 +7,31 @@ RSpec.describe SimpleCovMcp do
   # 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'])
+      allow(described_class::ModeDetector).to receive(:cli_mode?).with(['--force-cli'])
         .and_return(true)
-      expect(SimpleCovMcp::CoverageCLI).to receive_message_chain(:new, :run)
-      SimpleCovMcp.run(['--force-cli'])
+      cli = instance_double(described_class::CoverageCLI, run: nil)
+      allow(described_class::CoverageCLI).to receive(:new).and_return(cli)
+
+      described_class.run(['--force-cli'])
+
+      expect(described_class::ModeDetector).to have_received(:cli_mode?).with(['--force-cli'])
+      expect(described_class::CoverageCLI).to have_received(:new)
+      expect(cli).to have_received(:run)
+    end
+  end
+
+  # When no thread-local context exists, active_log_file= creates one
+  # from the default context rather than modifying an existing one.
+  describe '.active_log_file=' do
+    it 'creates context from default when no current context exists' do
+      Thread.current[:simplecov_mcp_context] = nil
+
+      described_class.active_log_file = '/tmp/test.log'
+
+      expect(described_class.context).not_to be_nil
+      expect(described_class.active_log_file).to eq('/tmp/test.log')
+    ensure
+      described_class.active_log_file = File::NULL
     end
   end
 end

data/spec/simplecov_mcp/formatters/source_formatter_spec.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::Formatters::SourceFormatter do
+  subject(:formatter) { described_class.new(color_enabled: color_enabled) }
+
+  let(:color_enabled) { false }
+  let(:model) { instance_double(SimpleCovMcp::CoverageModel) }
+  let(:path) { 'lib/foo.rb' }
+  let(:abs_path) { File.expand_path(path) }
+  let(:source_content) do
+    <<~RUBY
+      class Foo
+        def bar
+          puts 'bar'
+        end
+      end
+    RUBY
+  end
+  let(:coverage_lines) { [1, 1, 0, nil, nil] } # Line 3 is uncovered
+
+  before do
+    allow(model).to receive(:raw_for).with(path).and_return(
+      'file' => abs_path,
+      'lines' => coverage_lines
+    )
+    allow(File).to receive(:file?).with(abs_path).and_return(true)
+    allow(File).to receive(:readlines).with(abs_path, chomp: true)
+      .and_return(source_content.lines(chomp: true))
+  end
+
+  describe '#format_source_for' do
+    context 'when source is available' do
+      it 'renders formatted source lines with line numbers and markers' do
+        # Full mode should print every line with coverage markers and numbering.
+        result = formatter.format_source_for(model, path, mode: :full)
+
+        expect(result.lines(chomp: true)).to eq(
+          [
+            '  Line     | Source',
+            '------  ---+-------------------------------------------------------------',
+            '     1   ✓ | class Foo',
+            '     2   ✓ |   def bar',
+            "     3   · |     puts 'bar'",
+            '     4     |   end',
+            '     5     | end'
+          ]
+        )
+      end
+
+      it 'marks covered lines with a checkmark' do
+        # Two covered lines should each get a ✓ in the rendered output.
+        result = formatter.format_source_for(model, path, mode: :full)
+        # covered: true -> '✓', false -> '·', nil -> ' '
+        expect(result.count('✓')).to eq(2)
+        expect(result.lines[2]).to match(/\b1\s+✓ \| class Foo/)
+        expect(result.lines[3]).to match(/\b2\s+✓ \|   def bar/)
+      end
+
+      it 'marks uncovered lines with a dot' do
+        # The single uncovered line should be marked with a dot.
+        result = formatter.format_source_for(model, path, mode: :full)
+        expect(result.count('·')).to eq(1)
+        expect(result.lines[4]).to match(/\b3\s+· \|     puts 'bar'/)
+      end
+
+      it 'returns only header when mode is nil (default)' do
+        # Default mode skips body rows but still emits the header scaffold.
+        result = formatter.format_source_for(model, path)
+        # Example header-only output:
+        #   Line     | Source
+        # ------  ---+-------------------------------------------------------------
+        expect(result).not_to include('class Foo')
+        expect(result).to include('Line', 'Source')
+      end
+    end
+
+    context 'when source file is not found' do
+      it 'returns fallback message' do
+        # Simulate missing file; formatter should not raise and should return a placeholder.
+        allow(File).to receive(:file?).with(abs_path).and_return(false)
+        expect(formatter.format_source_for(model, path)).to eq('[source not available]')
+      end
+    end
+
+    context 'when raw coverage data is missing' do
+      it 'returns fallback message' do
+        # No coverage entry for the path should also trigger the placeholder.
+        allow(model).to receive(:raw_for).with(path).and_return(nil)
+        expect(formatter.format_source_for(model, path)).to eq('[source not available]')
+      end
+    end
+
+    context 'when an error occurs during formatting' do
+      it 'returns fallback message instead of crashing' do
+        # Create a pathological coverage array with an object that raises on to_i
+        bad_object = Object.new
+        def bad_object.to_i = raise(StandardError, 'Bad data')
+        def bad_object.nil? = false
+
+        bad_coverage = [1, 1, bad_object, nil, nil]
+
+        allow(model).to receive(:raw_for).with(path)
+          .and_return('file' => abs_path, 'lines' => bad_coverage)
+
+        result = formatter.format_source_for(model, path, mode: :full)
+        expect(result).to eq('[source not available]')
+      end
+
+      it 'propagates ArgumentError' do
+        expect do
+          formatter.format_source_for(model, path, mode: :full, context: -1)
+        end.to raise_error(ArgumentError, 'Context lines cannot be negative')
+      end
+    end
+
+    context 'with color enabled' do
+      let(:color_enabled) { true }
+
+      it 'includes ANSI color codes' do
+        # Markers should be wrapped with green/red ANSI sequences when colors are on.
+        # Example colored line: "     1  \e[32m✓\e[0m | class Foo"
+        result = formatter.format_source_for(model, path, mode: :full)
+        expect(result).to include("\e[32m", "\e[31m") # green for checkmark, red for dot
+        expect(result.lines[2]).to include("\e[32m✓\e[0m") # line 1 checkmark is green
+        expect(result.lines[3]).to include("\e[32m✓\e[0m") # line 2 checkmark is green
+        expect(result.lines[4]).to include("\e[31m·\e[0m") # line 3 dot is red
+      end
+    end
+  end
+
+  describe '#build_source_payload' do
+    it 'returns row data when source is available' do
+      # Payload should mirror the row hashes used by CLI formatting.
+      result = formatter.build_source_payload(model, path, mode: :full)
+      expect(result).to be_a(Array)
+      expect(result.size).to eq(5)
+      expect(result.first).to include('code' => 'class Foo', 'line' => 1)
+    end
+
+    it 'returns nil when raw coverage is missing' do
+      # Without coverage data, there is no payload to build.
+      allow(model).to receive(:raw_for).with(path).and_return(nil)
+      expect(formatter.build_source_payload(model, path)).to be_nil
+    end
+
+    it 'returns nil when source file is missing' do
+      # Missing source file should also produce a nil payload.
+      allow(File).to receive(:file?).with(abs_path).and_return(false)
+      expect(formatter.build_source_payload(model, path)).to be_nil
+    end
+  end
+
+  describe '#build_source_rows' do
+    it 'raises error for negative context count' do
+      # Negative context should raise ArgumentError
+      expect do
+        formatter.build_source_rows(
+          source_content.lines(chomp: true),
+          coverage_lines,
+          mode: :uncovered,
+          context: -1
+        )
+      end.to raise_error(ArgumentError, 'Context lines cannot be negative')
+    end
+
+    it 'handles default context (2 lines)' do
+      # With the default context of 2, uncovered lines pull in surrounding rows.
+      rows = formatter.build_source_rows(
+        source_content.lines(chomp: true),
+        coverage_lines,
+        mode: :uncovered,
+        context: 2
+      )
+      # Uncovered is line 3. Context 2 means lines 1..5 (indexes 0..4).
+      # Total line count is 5, so all lines should be included.
+      expect(rows.size).to eq(5)
+    end
+
+    it 'handles bad context input (non-numeric)' do
+      # Non-numeric context coerces to 0 via to_i, so only the miss is included.
+      rows = formatter.build_source_rows(
+        source_content.lines(chomp: true),
+        coverage_lines,
+        mode: :uncovered,
+        context: 'bad'
+      )
+      # "bad".to_i is 0 so context should be 0.
+      # Uncovered is line 3.
+      expect(rows.size).to eq(1)
+      expect(rows.first['line']).to eq(3)
+    end
+
+    it 'handles context input that raises error on to_i conversion' do
+      # Create an object where to_i raises an error
+      bad_context = Object.new
+      def bad_context.to_i = raise(StandardError, 'Cannot convert')
+
+      # Falling back to default context should still include surrounding lines.
+      rows = formatter.build_source_rows(
+        source_content.lines(chomp: true),
+        coverage_lines,
+        mode: :uncovered,
+        context: bad_context
+      )
+      # Should fall back to default context of 2
+      # Uncovered is line 3. Context 2 means lines 1..5 (indexes 0..4).
+      # Total lines is 5. So all lines should be included.
+      expect(rows.size).to eq(5)
+    end
+
+    it 'handles nil coverage lines defensively' do
+      # Nil coverage array should not raise; hits/covered become nil.
+      # This covers the "coverage data missing entirely" path; in real coverage we'd see 1/0 hits.
+      # Expected rows when coverage is nil:
+      # [
+      #   { 'line' => 1, 'code' => 'class Foo', 'hits' => nil, 'covered' => nil },
+      #   { 'line' => 2, 'code' => '  def bar', 'hits' => nil, 'covered' => nil },
+      #   { 'line' => 3, 'code' => "    puts 'bar'", 'hits' => nil, 'covered' => nil },
+      #   { 'line' => 4, 'code' => '  end', 'hits' => nil, 'covered' => nil },
+      #   { 'line' => 5, 'code' => 'end', 'hits' => nil, 'covered' => nil }
+      # ]
+      # And the formatted output (markers blank because coverage is missing) would be:
+      #   Line     | Source
+      # ------  ---+-------------------------------------------------------------
+      #      1     | class Foo
+      #      2     |   def bar
+      #      3     |     puts 'bar'
+      #      4     |   end
+      #      5     | end
+      rows = formatter.build_source_rows(
+        source_content.lines(chomp: true),
+        nil,
+        mode: :full,
+        context: 2
+      )
+      expect(rows.size).to eq(5)
+      expect(rows.first['hits']).to be_nil
+    end
+  end
+
+  describe '#format_detailed_rows' do
+    it 'formats rows into a table' do
+      # Detailed mode should align numeric columns and boolean covered flags.
+      rows = [
+        { 'line' => 1, 'hits' => 5, 'covered' => true },
+        { 'line' => 2, 'hits' => 0, 'covered' => false }
+      ]
+      # Expected table:
+      #   Line    Hits  Covered
+      #   -----   ----  -------
+      #       1      5      yes
+      #       2      0       no
+      result = formatter.format_detailed_rows(rows)
+      expect(result).to include('Line', 'Hits', 'Covered', '5', 'yes', 'no')
+    end
+  end
+
+  describe 'private #fetch_raw error handling' do
+    it 'returns nil if model raises error' do
+      # fetch_raw should swallow model errors and return nil instead of propagating.
+      allow(model).to receive(:raw_for).and_raise(StandardError)
+      expect(formatter.send(:fetch_raw, model, path)).to be_nil
+    end
+  end
+end

data/spec/simplecov_mcp/formatters_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::Formatters do
+  describe '.formatter_for' do
+    it 'returns a lambda for known format' do
+      expect(described_class.formatter_for(:json)).to respond_to(:call)
+    end
+
+    it 'raises ArgumentError for unknown format' do
+      expect { described_class.formatter_for(:unknown) }
+        .to raise_error(ArgumentError, /Unknown format: unknown/)
+    end
+  end
+
+  describe '.ensure_requirements_for' do
+    it 'requires the library if needed' do
+      # We rely on the fact that 'yaml' is in FORMAT_REQUIRES
+      expect(described_class).to receive(:require).with('yaml')
+      described_class.ensure_requirements_for(:yaml)
+    end
+
+    it 'does nothing if no requirement' do
+      expect(described_class).not_to receive(:require)
+      described_class.ensure_requirements_for(:json) # JSON already required by app
+    end
+  end
+
+  describe '.format' do
+    let(:obj) { { 'foo' => 'bar' } }
+
+    [
+      [:json, '{"foo":"bar"}', :eq],
+      [:pretty_json, "{\n  \"foo\": \"bar\"\n}", :include],
+      [:table, { 'foo' => 'bar' }, :eq],
+      [:yaml, "---\nfoo: bar\n", :include]
+    ].each do |format, expected, matcher|
+      it "formats as #{format}" do
+        result = described_class.format(obj, format)
+        expect(result).to send(matcher, expected)
+      end
+    end
+
+    context 'when a required gem is missing' do
+      before do
+        error = LoadError.new('cannot load such file -- awesome_print')
+        allow(described_class).to receive(:require).with('awesome_print').and_raise(error)
+      end
+
+      it 'raises a helpful LoadError' do
+        expect { described_class.format(obj, :awesome_print) }
+          .to raise_error(LoadError, /requires the 'awesome_print' gem/)
+      end
+    end
+
+    context 'when awesome_print is available' do
+      before do
+        # Stub require on the module for ensure_requirements_for
+        allow(described_class).to receive(:require).with('awesome_print')
+
+        # Stub global require for the lambda's internal require
+        allow(Kernel).to receive(:require).and_call_original
+        allow(Kernel).to receive(:require).with('awesome_print').and_return(true)
+
+        # Mock .ai on the object
+        allow(obj).to receive(:ai).and_return('awesome output')
+      end
+
+      it 'formats using awesome_print' do
+        result = described_class.format(obj, :awesome_print)
+        expect(result).to eq('awesome output')
+      end
+    end
+  end
+end

data/spec/simplecov_mcp/presenters/base_coverage_presenter_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::Presenters::BaseCoveragePresenter do
+  let(:model) { instance_double(SimpleCovMcp::CoverageModel) }
+  let(:path) { 'lib/foo.rb' }
+  let(:presenter) { described_class.new(model: model, path: path) }
+
+  describe '#initialize' do
+    it 'sets model and path' do
+      expect(presenter.model).to eq(model)
+      expect(presenter.path).to eq(path)
+    end
+  end
+
+  describe '#absolute_payload' do
+    it 'raises NotImplementedError because build_payload is abstract' do
+      expect { presenter.absolute_payload }.to raise_error(NotImplementedError)
+    end
+  end
+
+  context 'with a concrete implementation' do
+    let(:concrete_class) do
+      Class.new(described_class) do
+        # Provide a concrete implementation of the abstract build_payload method
+        # for testing the BaseCoveragePresenter functionality
+        def build_payload
+          { 'file' => path, 'data' => 'test' }
+        end
+      end
+    end
+    let(:presenter) { concrete_class.new(model: model, path: path) }
+    let(:payload_with_stale) { { 'file' => path, 'data' => 'test', 'stale' => false } }
+
+    before do
+      allow(model).to receive(:staleness_for).with(path).and_return(false)
+      allow(model).to receive(:relativize).with(payload_with_stale).and_return(payload_with_stale)
+    end
+
+    describe '#absolute_payload' do
+      it 'merges stale status into payload' do
+        expect(presenter.absolute_payload).to include('stale' => false)
+        expect(presenter.absolute_payload).to include('data' => 'test')
+      end
+
+      it 'caches the result' do
+        r1 = presenter.absolute_payload
+        r2 = presenter.absolute_payload
+        expect(r1).to equal(r2)
+      end
+    end
+
+    describe '#relativized_payload' do
+      it 'delegates to model.relativize' do
+        expect(model).to receive(:relativize).with(presenter.absolute_payload)
+        presenter.relativized_payload
+      end
+
+      it 'caches the result' do
+        presenter.relativized_payload
+        expect(model).to have_received(:relativize).once
+        presenter.relativized_payload
+      end
+    end
+
+    describe '#stale' do
+      it 'delegates to absolute_payload' do
+        expect(presenter.stale).to be(false)
+      end
+    end
+
+    describe '#relative_path' do
+      it 'delegates to relativized_payload' do
+        expect(presenter.relative_path).to eq('lib/foo.rb')
+      end
+    end
+  end
+end