simplecov-mcp 0.1.0 → 0.2.1

data/spec/cli_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::CoverageCLI do
+  let(:root) { (FIXTURES / 'project1').to_s }
+
+  def run_cli(*argv)
+    cli = described_class.new
+    silence_output do |out, _err|
+      cli.run(argv.flatten)
+      return out.string
+    end
+  end
+
+  it 'prints summary as JSON for a file' do
+    output = run_cli('summary', 'lib/foo.rb', '--json', '--root', root, '--resultset', 'coverage')
+    data = JSON.parse(output)
+    expect(data['file']).to end_with('lib/foo.rb')
+    expect(data['summary']).to include('covered' => 2, 'total' => 3)
+  end
+
+  it 'prints raw lines as JSON' do
+    output = run_cli('raw', 'lib/foo.rb', '--json', '--root', root, '--resultset', 'coverage')
+    data = JSON.parse(output)
+    expect(data['file']).to end_with('lib/foo.rb')
+    expect(data['lines']).to eq([1, 0, nil, 2])
+  end
+
+  it 'prints uncovered lines as JSON' do
+    output = run_cli('uncovered', 'lib/foo.rb', '--json', '--root', root, '--resultset', 'coverage')
+    data = JSON.parse(output)
+    expect(data['uncovered']).to eq([2])
+    expect(data['summary']).to include('total' => 3)
+  end
+
+  it 'prints detailed rows as JSON' do
+    output = run_cli('detailed', 'lib/foo.rb', '--json', '--root', root, '--resultset', 'coverage')
+    data = JSON.parse(output)
+    expect(data['lines']).to be_an(Array)
+    expect(data['lines'].first).to include('line', 'hits', 'covered')
+  end
+
+  it 'lists all files as JSON with sort order' do
+    output = run_cli('list', '--json', '--root', root, '--resultset', 'coverage', '--sort-order', 'ascending')
+    asc = JSON.parse(output)
+    expect(asc['files']).to be_an(Array)
+    expect(asc['files'].first['file']).to end_with('lib/bar.rb')
+
+    # Includes counts for total/ok/stale and they are consistent
+    expect(asc['counts']).to include('total', 'ok', 'stale')
+    total = asc['counts']['total']
+    ok = asc['counts']['ok']
+    stale = asc['counts']['stale']
+    expect(total).to eq(asc['files'].length)
+    expect(ok + stale).to eq(total)
+
+    output = run_cli('list', '--json', '--root', root, '--resultset', 'coverage', '--sort-order', 'descending')
+    desc = JSON.parse(output)
+    expect(desc['files'].first['file']).to end_with('lib/foo.rb')
+  end
+
+  it 'exposes expected subcommands via constant' do
+    expect(described_class::SUBCOMMANDS).to eq(%w[list summary raw uncovered detailed version])
+  end
+
+  it 'can include source in JSON payload (nil if file missing)' do
+    output = run_cli('summary', 'lib/foo.rb', '--json', '--root', root, '--resultset', 'coverage', '--source')
+    data = JSON.parse(output)
+    expect(data).to have_key('source')
+  end
+end

data/spec/cli_table_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::CoverageCLI do
+  let(:root) { (FIXTURES / 'project1').to_s }
+
+  def run_cli(*argv)
+    cli = described_class.new
+    silence_output do |out, _err|
+      cli.run(argv.flatten)
+      return out.string
+    end
+  end
+
+  it 'prints default table when no subcommand is given' do
+    output = run_cli('--root', root, '--resultset', 'coverage')
+
+    # Contains a header row and at least one data row with expected columns
+    expect(output).to include('File')
+    expect(output).to include('Covered')
+    expect(output).to include('Total')
+
+    # Should list fixture files from the demo project
+    expect(output).to include('lib/foo.rb')
+    expect(output).to include('lib/bar.rb')
+  end
+end

data/spec/cli_usage_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::CoverageCLI do
+  let(:root) { (FIXTURES / 'project1').to_s }
+
+  def run_cli_with_status(*argv)
+    cli = described_class.new
+    status = nil
+    out_str = err_str = nil
+    silence_output do |out, err|
+      begin
+        cli.run(argv.flatten)
+        status = 0
+      rescue SystemExit => e
+        status = e.status
+      end
+      out_str = out.string
+      err_str = err.string
+    end
+    [out_str, err_str, status]
+  end
+
+  it 'errors with usage when summary path is missing' do
+    _out, err, status = run_cli_with_status('summary', '--root', root, '--resultset', 'coverage')
+    expect(status).to eq(1)
+    expect(err).to include('Usage: simplecov-mcp summary <path>')
+  end
+
+  it 'treats unknown subcommand as no subcommand and prints default table' do
+    out, err, status = run_cli_with_status('bogus', '--root', root, '--resultset', 'coverage')
+    expect(status).to eq(0)
+    expect(err).to eq("")
+    expect(out).to include('File')
+    expect(out).to include('lib/foo.rb')
+  end
+
+  it 'list honors stale=error and tracked_globs by exiting 1 when project is stale' do
+    tmp = File.join(root, 'lib', 'brand_new_file_for_cli_usage_spec.rb')
+    begin
+      File.write(tmp, "# new file\n")
+      _out, err, status = run_cli_with_status('list', '--root', root, '--resultset', 'coverage', '--stale', 'error', '--tracked-globs', 'lib/**/*.rb')
+      expect(status).to eq(1)
+      expect(err).to include('Coverage data stale (project)')
+    ensure
+      File.delete(tmp) if File.exist?(tmp)
+    end
+  end
+
+  it 'list with stale=off prints table and exits 0' do
+    out, err, status = run_cli_with_status('list', '--root', root, '--resultset', 'coverage', '--stale', 'off')
+    expect(status).to eq(0)
+    expect(err).to eq("")
+    expect(out).to include('File')
+    expect(out).to include('lib/foo.rb')
+  end
+end

data/spec/coverage_table_tool_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'simple_cov_mcp/tools/coverage_table_tool'
+
+RSpec.describe SimpleCovMcp::Tools::CoverageTableTool do
+  let(:root) { (FIXTURES / 'project1').to_s }
+  let(:server_context) { instance_double('ServerContext').as_null_object }
+
+  before do
+    stub_const('MCP::Tool::Response', Struct.new(:payload))
+  end
+
+  def run_tool(stale: 'off')
+    # Stub the CoverageModel to avoid file system access
+    model = instance_double(SimpleCovMcp::CoverageModel)
+    allow(SimpleCovMcp::CoverageModel).to receive(:new).and_return(model)
+    allow(model).to receive(:all_files).and_return([
+      { 'file' => "#{root}/lib/foo.rb", 'percentage' => 100.0, 'covered' => 10, 'total' => 10, 'stale' => false },
+      { 'file' => "#{root}/lib/bar.rb", 'percentage' =>  50.0, 'covered' =>  5, 'total' => 10, 'stale' => true }
+    ])
+
+    response = described_class.call(root: root, stale: stale, server_context: server_context)
+    response.payload.first[:text]
+  end
+
+  it 'returns a formatted table as a string' do
+    output = run_tool
+
+    # Contains a header row and at least one data row with expected columns
+    expect(output).to include('File')
+    expect(output).to include('Covered')
+    expect(output).to include('Total')
+    # Staleness column header reads 'Stale'
+    expect(output).to include(' │ Stale │')
+
+    # Should list fixture files from the demo project
+    expect(output).to include('lib/foo.rb')
+    expect(output).to include('lib/bar.rb')
+
+    # Check for table borders
+    expect(output).to include('┌')
+    expect(output).to include('│')
+    expect(output).to include('└')
+
+    # Summary counts line appears after the table
+    expect(output).to include('Files: total 2, ok 1, stale 1')
+  end
+
+  it 'configures the CLI to enforce stale checking when requested' do
+    model = instance_double(SimpleCovMcp::CoverageModel)
+    allow(model).to receive(:all_files).and_return([
+      { 'file' => "#{root}/lib/foo.rb", 'percentage' => 100.0, 'covered' => 10, 'total' => 10, 'stale' => false }
+    ])
+    expect(SimpleCovMcp::CoverageModel).to receive(:new).with(
+      root: root,
+      resultset: nil,
+      staleness: 'error',
+      tracked_globs: nil
+    ).and_return(model)
+
+    described_class.call(root: root, stale: 'error', server_context: server_context)
+  end
+end

data/spec/error_handler_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::ErrorHandler do
+  let(:logger) do
+    Class.new do
+      attr_reader :messages
+      def initialize; @messages = []; end
+      def error(msg); @messages << msg; end
+    end.new
+  end
+
+  subject(:handler) { described_class.new(log_errors: true, show_stack_traces: false, logger: logger) }
+
+  it 'maps filesystem errors to friendly custom errors' do
+    e = handler.convert_standard_error(Errno::EISDIR.new('Is a directory @ rb_sysopen - a_dir'))
+    expect(e).to be_a(SimpleCovMcp::NotAFileError)
+
+    e = handler.convert_standard_error(Errno::ENOENT.new('No such file or directory @ rb_sysopen - missing.txt'))
+    expect(e).to be_a(SimpleCovMcp::FileNotFoundError)
+
+    e = handler.convert_standard_error(Errno::EACCES.new('Permission denied @ rb_sysopen - secret'))
+    expect(e).to be_a(SimpleCovMcp::FilePermissionError)
+  end
+
+  it 'maps JSON::ParserError to CoverageDataError' do
+    e = handler.convert_standard_error(JSON::ParserError.new('unexpected token'))
+    expect(e).to be_a(SimpleCovMcp::CoverageDataError)
+    expect(e.user_friendly_message).to include('Invalid coverage data format')
+  end
+
+  it 'maps ArgumentError by message' do
+    e = handler.convert_standard_error(ArgumentError.new('wrong number of arguments (given 1, expected 2)'))
+    expect(e).to be_a(SimpleCovMcp::UsageError)
+
+    e = handler.convert_standard_error(ArgumentError.new('invalid option'))
+    expect(e).to be_a(SimpleCovMcp::ConfigurationError)
+  end
+
+  it 'maps NoMethodError to CoverageDataError with helpful info' do
+    e = handler.convert_standard_error(NoMethodError.new("undefined method `fetch' for #<Hash:0x123>"))
+    expect(e).to be_a(SimpleCovMcp::CoverageDataError)
+    expect(e.user_friendly_message).to include('Invalid coverage data structure')
+  end
+
+  it 'maps runtime strings from util to friendly errors' do
+    e = handler.convert_standard_error(RuntimeError.new('No coverage entry found for /tmp/foo.rb'))
+    expect(e).to be_a(SimpleCovMcp::FileError)
+    expect(e.user_friendly_message).to include('No coverage data found for file')
+
+    e = handler.convert_standard_error(RuntimeError.new('Could not find .resultset.json under /path; run tests'))
+    expect(e).to be_a(SimpleCovMcp::CoverageDataError)
+    expect(e.user_friendly_message).to include('run your tests first')
+
+    e = handler.convert_standard_error(RuntimeError.new('No .resultset.json found in directory: /path'))
+    expect(e).to be_a(SimpleCovMcp::CoverageDataError)
+
+    e = handler.convert_standard_error(RuntimeError.new('Specified resultset not found: /nowhere/file.json'))
+    expect(e).to be_a(SimpleCovMcp::ResultsetNotFoundError)
+  end
+
+  it 'logs via provided logger' do
+    begin
+      handler.handle_error(Errno::ENOENT.new('No such file or directory @ rb_sysopen - x'), context: 'test', reraise: false)
+    rescue StandardError
+      # reraise disabled
+    end
+    expect(logger.messages.join).to include('Error in test')
+  end
+end
+

data/spec/errors_stale_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::CoverageDataStaleError do
+  it 'formats a detailed, user-friendly message with UTC/local, delta, and resultset' do
+    file_time = Time.at(1_000) # 1970-01-01T00:16:40Z
+    cov_epoch = 0              # 1970-01-01T00:00:00Z
+    err = described_class.new(
+      'Coverage data appears stale for foo.rb',
+      nil,
+      file_path: 'foo.rb',
+      file_mtime: file_time,
+      cov_timestamp: cov_epoch,
+      src_len: 10,
+      cov_len: 8,
+      resultset_path: '/path/to/coverage/.resultset.json'
+    )
+
+    msg = err.user_friendly_message
+
+    expect(msg).to include('Coverage data stale: Coverage data appears stale for foo.rb')
+    expect(msg).to match(/File\s*-\s*time:\s*1970-01-01T00:16:40Z/)
+    expect(msg).to include('(local ') # do not assert exact local tz
+    expect(msg).to match(/Coverage\s*-\s*time:\s*1970-01-01T00:00:00Z/)
+    expect(msg).to match(/lines:\s*10/)
+    expect(msg).to match(/lines:\s*8/)
+    expect(msg).to match(/Delta\s*- file is \+1000s newer than coverage/)
+    expect(msg).to include('Resultset - /path/to/coverage/.resultset.json')
+  end
+
+  it 'handles missing timestamps gracefully' do
+    err = described_class.new(
+      'Coverage data appears stale for bar.rb',
+      nil,
+      file_path: 'bar.rb',
+      file_mtime: nil,
+      cov_timestamp: nil,
+      src_len: 1,
+      cov_len: 0,
+      resultset_path: nil
+    )
+    msg = err.user_friendly_message
+    expect(msg).to include('Coverage data stale: Coverage data appears stale for bar.rb')
+    expect(msg).to match(/File\s*-\s*time:\s*not found.*lines: 1/m)
+    expect(msg).to match(/Coverage\s*-\s*time:\s*not found.*lines: 0/m)
+    expect(msg).not_to include('Delta')
+  end
+end

data/spec/fixtures/project1/lib/bar.rb

@@ -0,0 +1,4 @@
+puts 'bar line 1 (uncovered)'
+puts 'bar line 2 (uncovered)'
+puts 'bar line 3'
+

data/spec/fixtures/project1/lib/foo.rb

@@ -0,0 +1,5 @@
+puts 'foo line 1'
+puts 'foo line 2 (uncovered)'
+
+puts 'foo line 4'
+

data/spec/help_tool_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'simple_cov_mcp/tools/help_tool'
+
+RSpec.describe SimpleCovMcp::Tools::HelpTool do
+  let(:server_context) { instance_double('ServerContext').as_null_object }
+
+  before do
+    response_class = Class.new do
+      attr_reader :payload, :meta
+
+      def initialize(payload)
+        @payload = payload
+        @meta = nil
+      end
+    end
+    stub_const('MCP::Tool::Response', response_class)
+  end
+
+  it 'returns guidance for each registered tool' do
+    response = described_class.call(server_context: server_context)
+    expect(response.meta).to be_nil
+
+    payload = response.payload.first
+    expect(payload['type']).to eq('text')
+
+    data = JSON.parse(payload['text'])
+    tool_names = data['tools'].map { |entry| entry['tool'] }
+
+    expect(tool_names).to include('coverage_summary_tool', 'uncovered_lines_tool', 'all_files_coverage_tool', 'coverage_table_tool', 'version_tool')
+    expect(data['tools']).to all(include('use_when', 'avoid_when', 'inputs', 'example'))
+  end
+
+  it 'filters entries when a query is provided' do
+    response = described_class.call(query: 'uncovered', server_context: server_context)
+    payload = response.payload.first
+    data = JSON.parse(payload['text'])
+
+    expect(data['tools']).not_to be_empty
+    expect(data['tools']).to all(satisfy do |entry|
+      combined = [entry['tool'], entry['label'], entry['use_when'], entry['avoid_when']].compact.join(' ').downcase
+      combined.include?('uncovered')
+    end)
+    expect(data['tools'].map { |entry| entry['tool'] }).to include('uncovered_lines_tool')
+  end
+end

data/spec/legacy_shim_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Legacy require shim' do
+  it "defines SimpleCov::Mcp aliasing SimpleCovMcp" do
+    # Ensure the legacy file itself is executed for coverage and behavior
+    load File.expand_path('../../lib/simple_cov/mcp.rb', __FILE__)
+    expect(defined?(SimpleCov::Mcp)).to be_truthy
+    expect(SimpleCov::Mcp).to eq(SimpleCovMcp)
+  end
+end
+

data/spec/mcp_server_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::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)
+
+    # 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)
+
+    server = described_class.new
+    # Error handler should be set for MCP server usage (factory selection).
+    expect(SimpleCovMcp.error_handler).to be_a(SimpleCovMcp::ErrorHandler)
+
+    # Run should construct server and open transport
+    server.run
+    # 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
+
+    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('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')
+  end
+end

data/spec/model_staleness_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::CoverageModel do
+  let(:root) { (FIXTURES / 'project1').to_s }
+  
+  def with_stubbed_coverage_timestamp(ts) = begin
+    allow(SimpleCovMcp::CovUtil).to receive(:latest_timestamp).and_return(ts)
+    yield
+  end
+
+  it "raises stale error when staleness mode is 'error' and file is newer" do
+    with_stubbed_coverage_timestamp(0) do
+      model = described_class.new(root: root, staleness: 'error')
+      expect {
+        model.summary_for('lib/foo.rb')
+      }.to raise_error(SimpleCovMcp::CoverageDataStaleError, /stale/i)
+    end
+  end
+
+  it "does not check staleness when mode is 'off'" do
+    with_stubbed_coverage_timestamp(0) do
+      model = described_class.new(root: root, staleness: 'off')
+      expect { model.summary_for('lib/foo.rb') }.not_to raise_error
+    end
+  end
+  it 'all_files raises project-level stale when any source file is newer than coverage' do
+    with_stubbed_coverage_timestamp(0) do
+      model = described_class.new(root: root, staleness: 'error')
+      expect { model.all_files }.to raise_error(SimpleCovMcp::CoverageDataProjectStaleError)
+    end
+  end
+
+  it 'all_files detects new files via tracked_globs' do
+    with_stubbed_coverage_timestamp(Time.now.to_i) do
+      tmp = File.join(root, 'lib', 'brand_new_file.rb')
+      begin
+        File.write(tmp, "# new file\n")
+        model = described_class.new(root: root, staleness: 'error')
+        expect {
+          model.all_files(tracked_globs: ['lib/**/*.rb'])
+        }.to raise_error(SimpleCovMcp::CoverageDataProjectStaleError)
+      ensure
+        File.delete(tmp) if File.exist?(tmp)
+      end
+    end
+  end
+end

data/spec/simplecov_mcp_model_spec.rb

@@ -1,54 +1,73 @@
 # frozen_string_literal: true
 
-require "spec_helper"
+require 'spec_helper'
 
-RSpec.describe Simplecov::Mcp::CoverageModel do
-  let(:root)  { (FIXTURES / "project1").to_s }
+RSpec.describe SimpleCovMcp::CoverageModel do
+  let(:root)  { (FIXTURES / 'project1').to_s }
   subject(:model) { described_class.new(root: root) }
 
-  describe "raw_for" do
-    it "returns absolute file and lines array" do
-      data = model.raw_for("lib/foo.rb")
-      expect(data[:file]).to eq(File.expand_path("lib/foo.rb", root))
-      expect(data[:lines]).to eq([1, 0, nil, 2])
+  describe 'raw_for' do
+    it 'returns absolute file and lines array' do
+      data = model.raw_for('lib/foo.rb')
+      expect(data['file']).to eq(File.expand_path('lib/foo.rb', root))
+      expect(data['lines']).to eq([1, 0, nil, 2])
     end
   end
 
-  describe "summary_for" do
-    it "computes covered/total/pct" do
-      data = model.summary_for("lib/foo.rb")
-      expect(data[:summary]["total"]).to eq(3)
-      expect(data[:summary]["covered"]).to eq(2)
-      expect(data[:summary]["pct"]).to be_within(0.01).of(66.67)
+  describe 'summary_for' do
+    it 'computes covered/total/pct' do
+      data = model.summary_for('lib/foo.rb')
+      expect(data['summary']['total']).to eq(3)
+      expect(data['summary']['covered']).to eq(2)
+      expect(data['summary']['pct']).to be_within(0.01).of(66.67)
     end
   end
 
-  describe "uncovered_for" do
-    it "lists uncovered executable line numbers" do
-      data = model.uncovered_for("lib/foo.rb")
-      expect(data[:uncovered]).to eq([2])
-      expect(data[:summary]["total"]).to eq(3)
+  describe 'uncovered_for' do
+    it 'lists uncovered executable line numbers' do
+      data = model.uncovered_for('lib/foo.rb')
+      expect(data['uncovered']).to eq([2])
+      expect(data['summary']['total']).to eq(3)
     end
   end
 
-  describe "detailed_for" do
-    it "returns per-line details for non-nil lines" do
-      data = model.detailed_for("lib/foo.rb")
-      expect(data[:lines]).to eq([
-        { line: 1, hits: 1, covered: true },
-        { line: 2, hits: 0, covered: false },
-        { line: 4, hits: 2, covered: true }
+  describe 'detailed_for' do
+    it 'returns per-line details for non-nil lines' do
+      data = model.detailed_for('lib/foo.rb')
+      expect(data['lines']).to eq([
+        { 'line' => 1, 'hits' => 1, 'covered' => true },
+        { 'line' => 2, 'hits' => 0, 'covered' => false },
+        { 'line' => 4, 'hits' => 2, 'covered' => true }
       ])
     end
   end
 
-  describe "all_files" do
-    it "sorts ascending by percentage then by file path" do
+  describe 'all_files' do
+    it 'sorts ascending by percentage then by file path' do
       files = model.all_files(sort_order: :ascending)
-      expect(files.first[:file]).to eq(File.expand_path("lib/bar.rb", root))
-      expect(files.first[:percentage]).to be_within(0.01).of(33.33)
-      expect(files.last[:file]).to eq(File.expand_path("lib/foo.rb", root))
+      expect(files.first['file']).to eq(File.expand_path('lib/bar.rb', root))
+      expect(files.first['percentage']).to be_within(0.01).of(33.33)
+      expect(files.last['file']).to eq(File.expand_path('lib/foo.rb', root))
     end
   end
-end
 
+  describe 'resultset directory handling' do
+    it 'accepts a directory containing .resultset.json' do
+      model = described_class.new(root: root, resultset: 'coverage')
+      data = model.summary_for('lib/foo.rb')
+      expect(data['summary']['total']).to eq(3)
+      expect(data['summary']['covered']).to eq(2)
+    end
+
+    it 'uses SIMPLECOV_RESULTSET when it is a directory' do
+      begin
+        ENV['SIMPLECOV_RESULTSET'] = 'coverage'
+        model = described_class.new(root: root)
+        data = model.summary_for('lib/foo.rb')
+        expect(data['summary']['covered']).to eq(2)
+      ensure
+        ENV.delete('SIMPLECOV_RESULTSET')
+      end
+    end
+  end
+end