simplecov-mcp 0.1.0 → 0.2.0

data/spec/cli_json_source_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::CoverageCLI do
+  let(:root) { (FIXTURES / 'project1').to_s }
+
+  def run_cli_json(*argv)
+    cli = described_class.new
+    out = nil
+    silence_output do |stdout, _stderr|
+      cli.run(argv.flatten)
+      out = stdout.string
+    end
+    JSON.parse(out)
+  end
+
+  it 'includes source rows in JSON for summary --source=full' do
+    data = run_cli_json('summary', 'lib/foo.rb', '--root', root, '--resultset', 'coverage', '--json', '--source=full')
+    expect(data['file']).to eq('lib/foo.rb')
+    expect(data['source']).to be_an(Array)
+    expect(data['source'].first).to include('line', 'code', 'hits', 'covered')
+  end
+
+  it 'includes source rows in JSON for uncovered --source=uncovered' do
+    data = run_cli_json('uncovered', 'lib/foo.rb', '--root', root, '--resultset', 'coverage', '--json', '--source=uncovered', '--source-context', '1')
+    expect(data['file']).to eq('lib/foo.rb')
+    expect(data['source']).to be_an(Array)
+    # Only a subset of lines around uncovered should appear
+    lines = data['source'].map { |h| h['line'] }
+    expect(lines).to include(2) # the uncovered line
+  end
+
+  it 'includes source rows in JSON for detailed --source=full' do
+    data = run_cli_json('detailed', 'lib/foo.rb', '--root', root, '--resultset', 'coverage', '--json', '--source=full')
+    expect(data['file']).to eq('lib/foo.rb')
+    expect(data['lines']).to be_an(Array)
+    expect(data['source']).to be_an(Array)
+  end
+
+  it 'renders uncovered source with various context sizes without error' do
+    [0, -5, 50].each do |ctx|
+      out, err, status = begin
+        cli = described_class.new
+        s = nil
+        o = e = nil
+        silence_output do |stdout, stderr|
+          begin
+            cli.run(['uncovered', 'lib/foo.rb', '--root', root, '--resultset', 'coverage', '--source=uncovered', '--source-context', ctx.to_s, '--no-color'])
+            s = 0
+          rescue SystemExit => ex
+            s = ex.status
+          end
+          o = stdout.string
+          e = stderr.string
+        end
+        [o, e, s]
+      end
+      expect(status).to eq(0)
+      expect(err).to eq("")
+      expect(out).to include('File: lib/foo.rb')
+      expect(out).to include('Uncovered lines: 2')
+    end
+  end
+
+  it 'respects --color and --no-color for source rendering' do
+    # Force color on
+    out_color = begin
+      cli = described_class.new
+      silence_output do |stdout, _stderr|
+        cli.run(['summary', 'lib/foo.rb', '--root', root, '--resultset', 'coverage', '--source', '--color'])
+        stdout.string
+      end
+    end
+    # If source table is rendered, it should contain ANSI escapes when color is on
+    if out_color.include?('Line') && out_color.include?('|')
+      expect(out_color).to match(/\e\[\d+m/)
+    else
+      expect(out_color).to include('[source not available]')
+    end
+
+    # Force color off: expect no ANSI sequences
+    out_nocolor = begin
+      cli = described_class.new
+      silence_output do |stdout, _stderr|
+        cli.run(['summary', 'lib/foo.rb', '--root', root, '--resultset', 'coverage', '--source', '--no-color'])
+        stdout.string
+      end
+    end
+    expect(out_nocolor).not_to match(/\e\[\d+m/)
+  end
+end

data/spec/cli_source_spec.rb

@@ -0,0 +1,37 @@
+# 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 'renders uncovered source without error for fixture file' do
+    out, err, status = run_cli_with_status(
+      'uncovered', 'lib/foo.rb', '--root', root, '--resultset', 'coverage',
+      '--source=uncovered', '--source-context', '1', '--no-color'
+    )
+    expect(status).to eq(0)
+    expect(err).to eq("")
+    expect(out).to include('File: lib/foo.rb')
+    expect(out).to include('Uncovered lines: 2')
+    # Accept either rendered source table or fallback message
+    expect(out).to satisfy { |s| s.include?('Line') || s.include?('[source not available]') }
+  end
+end

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, meta: nil)
+        @payload = payload
+        @meta = meta
+      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[:mimeType]).to eq('application/json')
+
+    payload = response.payload.first
+    expect(payload[:type]).to eq('json')
+
+    data = payload[:json]
+    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 = payload[:json]
+
+    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