simplecov-mcp 1.0.1 → 2.0.0

data/lib/simplecov_mcp.rb

@@ -3,6 +3,7 @@
 require 'json'
 require 'time'
 require 'pathname'
+require 'set' # rubocop:disable Lint/RedundantRequireStatement -- Ruby >= 3.4 requires explicit require for set; RuboCop targets 3.2
 require 'optparse'
 require 'mcp'
 require 'mcp/server/transports/stdio_transport'
@@ -17,13 +18,16 @@ require_relative 'simplecov_mcp/path_relativizer'
 require_relative 'simplecov_mcp/resultset_loader'
 require_relative 'simplecov_mcp/mode_detector'
 require_relative 'simplecov_mcp/model'
+require_relative 'simplecov_mcp/coverage_reporter'
 require_relative 'simplecov_mcp/base_tool'
 require_relative 'simplecov_mcp/tools/coverage_raw_tool'
 require_relative 'simplecov_mcp/tools/coverage_summary_tool'
 require_relative 'simplecov_mcp/tools/uncovered_lines_tool'
 require_relative 'simplecov_mcp/tools/coverage_detailed_tool'
 require_relative 'simplecov_mcp/tools/all_files_coverage_tool'
+require_relative 'simplecov_mcp/tools/coverage_totals_tool'
 require_relative 'simplecov_mcp/tools/coverage_table_tool'
+require_relative 'simplecov_mcp/tools/validate_tool'
 require_relative 'simplecov_mcp/tools/version_tool'
 require_relative 'simplecov_mcp/tools/help_tool'
 require_relative 'simplecov_mcp/mcp_server'
@@ -34,23 +38,26 @@ module SimpleCovMcp
     THREAD_CONTEXT_KEY = :simplecov_mcp_context
 
     def run(argv)
-      # Parse environment options for mode detection
-      env_opts = parse_env_opts_for_mode_detection
-      full_argv = env_opts + argv
+      # Prepend environment options once at entry point
+      full_argv = extract_env_opts + argv
 
       if ModeDetector.cli_mode?(full_argv)
-        CoverageCLI.new.run(argv) # CLI will re-parse env opts internally
+        # CLI mode: pass merged argv to CoverageCLI
+        CoverageCLI.new.run(full_argv)
       else
-        log_file = parse_log_file(full_argv)
+        # MCP server mode: parse config once from full_argv
+        require_relative 'simplecov_mcp/config_parser'
+        config = ConfigParser.parse(full_argv)
 
-        if log_file == 'stdout'
+        if config.log_file == 'stdout'
           raise ConfigurationError,
             'Logging to stdout is not permitted in MCP server mode as it interferes with ' \
             "the JSON-RPC protocol. Please use 'stderr' or a file path."
         end
 
-        handler = ErrorHandlerFactory.for_mcp_server
-        context = create_context(error_handler: handler, log_target: log_file, mode: :mcp_server)
+        handler = ErrorHandlerFactory.for_mcp_server(error_mode: config.error_mode)
+        context = create_context(error_handler: handler, log_target: config.log_file,
+          mode: :mcp)
         with_context(context) { MCPServer.new(context: context).run }
       end
     end
@@ -86,7 +93,7 @@ module SimpleCovMcp
       if active.nil? || active.log_target == previous_default.log_target
         Thread.current[THREAD_CONTEXT_KEY] = @default_context
       end
-      value
+      value # rubocop:disable Lint/Void -- return assigned log target for symmetry
     end
 
     def active_log_file
@@ -95,12 +102,12 @@ module SimpleCovMcp
 
     def active_log_file=(value)
       current = Thread.current[THREAD_CONTEXT_KEY]
-      if current
-        Thread.current[THREAD_CONTEXT_KEY] = current.with_log_target(value)
+      Thread.current[THREAD_CONTEXT_KEY] = if current
+        current.with_log_target(value)
       else
-        Thread.current[THREAD_CONTEXT_KEY] = default_context.with_log_target(value)
+        default_context.with_log_target(value)
       end
-      value
+      value # rubocop:disable Lint/Void -- return assigned log target for symmetry
     end
 
     def error_handler
@@ -111,27 +118,14 @@ module SimpleCovMcp
       @default_context = default_context.with_error_handler(handler)
     end
 
-    private
-
-    def default_context
+    private def default_context
       @default_context ||= AppContext.new(
         error_handler: ErrorHandlerFactory.for_cli,
         log_target: nil
       )
     end
 
-    def parse_log_file(argv)
-      log_file = nil
-      parser = OptionParser.new do |o|
-        # Define the option we're looking for
-        o.on('-l', '--log-file PATH') { |v| log_file = v }
-      end
-      # Parse arguments, but ignore errors and stop at the first non-option
-      parser.order!(argv.dup) {} rescue nil
-      log_file
-    end
-
-    def parse_env_opts_for_mode_detection
+    private def extract_env_opts
       require 'shellwords'
       opts_string = ENV['SIMPLECOV_MCP_OPTS']
       return [] unless opts_string && !opts_string.empty?
@@ -139,7 +133,7 @@ module SimpleCovMcp
       begin
         Shellwords.split(opts_string)
       rescue ArgumentError
-        [] # Ignore parsing errors for mode detection
+        [] # Ignore parsing errors
       end
     end
   end

data/spec/all_files_coverage_tool_spec.rb

@@ -4,6 +4,8 @@ require 'spec_helper'
 require 'simplecov_mcp/tools/all_files_coverage_tool'
 
 RSpec.describe SimpleCovMcp::Tools::AllFilesCoverageTool do
+  subject(:call_tool) { described_class.call(root: root, server_context: server_context) }
+
   let(:root) { (FIXTURES_DIR / 'project1').to_s }
   let(:server_context) { instance_double('ServerContext').as_null_object }
 
@@ -27,13 +29,12 @@ RSpec.describe SimpleCovMcp::Tools::AllFilesCoverageTool do
     allow(presenter).to receive(:relativized_payload).and_return(payload)
   end
 
-  subject { described_class.call(root: root, server_context: server_context) }
 
   it_behaves_like 'an MCP tool that returns text JSON'
 
   it 'returns all files coverage data with counts' do
-    response = subject
-    data, item = expect_mcp_text_json(response, expected_keys: ['files', 'counts'])
+    response = call_tool
+    data, _item = expect_mcp_text_json(response, expected_keys: ['files', 'counts'])
 
     files = data['files']
     counts = data['counts']

data/spec/{cli_config_spec.rb → app_config_spec.rb}

@@ -2,42 +2,41 @@
 
 require 'spec_helper'
 
-RSpec.describe SimpleCovMcp::CLIConfig do
+RSpec.describe SimpleCovMcp::AppConfig do
   describe '#initialize' do
     it 'creates a config with default values' do
       config = described_class.new
       expect(config.root).to eq('.')
-      expect(config.json).to be false
-      expect(config.sort_order).to eq(:ascending)
+      expect(config.format).to eq(:table)
+      expect(config.sort_order).to eq(:descending)
       expect(config.source_context).to eq(2)
-      expect(config.error_mode).to eq(:on)
-      expect(config.stale_mode).to eq(:off)
+      expect(config.error_mode).to eq(:log)
+      expect(config.staleness).to eq(:off)
       expect(config.resultset).to be_nil
       expect(config.source_mode).to be_nil
       expect(config.tracked_globs).to be_nil
       expect(config.log_file).to be_nil
-      expect(config.success_predicate).to be_nil
     end
 
     it 'allows overriding defaults via keyword arguments' do
       config = described_class.new(
         root: '/custom',
-        json: true,
+        format: :json,
         sort_order: :descending,
-        stale_mode: :error
+        staleness: :error
       )
       expect(config.root).to eq('/custom')
-      expect(config.json).to be true
+      expect(config.format).to eq(:json)
       expect(config.sort_order).to eq(:descending)
-      expect(config.stale_mode).to eq(:error)
+      expect(config.staleness).to eq(:error)
     end
 
     it 'is mutable (struct fields can be changed)' do
       config = described_class.new
       config.root = '/new/root'
-      config.json = true
+      config.format = :json
       expect(config.root).to eq('/new/root')
-      expect(config.json).to be true
+      expect(config.format).to eq(:json)
     end
   end
 
@@ -46,7 +45,7 @@ RSpec.describe SimpleCovMcp::CLIConfig do
       config = described_class.new(
         root: '/custom/root',
         resultset: '/custom/.resultset.json',
-        stale_mode: :error,
+        staleness: :error,
         tracked_globs: ['lib/**/*.rb']
       )
 
@@ -85,46 +84,52 @@ RSpec.describe SimpleCovMcp::CLIConfig do
 
   describe 'struct behavior' do
     it 'supports equality comparison' do
-      config1 = described_class.new(root: '/foo', json: true)
-      config2 = described_class.new(root: '/foo', json: true)
-      config3 = described_class.new(root: '/bar', json: true)
+      config1 = described_class.new(root: '/foo', format: :json)
+      config2 = described_class.new(root: '/foo', format: :json)
+      config3 = described_class.new(root: '/bar', format: :json)
 
       expect(config1).to eq(config2)
       expect(config1).not_to eq(config3)
     end
 
     it 'provides readable inspect output' do
-      config = described_class.new(root: '/test', json: true)
+      config = described_class.new(root: '/test', format: :json)
       output = config.inspect
       expect(output).to include('root="/test"')
-      expect(output).to include('json=true')
+      expect(output).to include('format=:json')
     end
 
     it 'converts to hash' do
-      config = described_class.new(root: '/test', json: true)
+      config = described_class.new(root: '/test', format: :json)
       hash = config.to_h
       expect(hash).to be_a(Hash)
       expect(hash[:root]).to eq('/test')
-      expect(hash[:json]).to be true
+      expect(hash[:format]).to eq(:json)
     end
   end
 
   describe 'symbol enumerated values' do
+    it 'uses symbols for format' do
+      config = described_class.new(format: :json)
+      expect(config.format).to eq(:json)
+      expect(config.format).to be_a(Symbol)
+    end
+
     it 'uses symbols for sort_order' do
       config = described_class.new(sort_order: :descending)
       expect(config.sort_order).to eq(:descending)
       expect(config.sort_order).to be_a(Symbol)
     end
 
-    it 'uses symbols for stale_mode' do
-      config = described_class.new(stale_mode: :error)
-      expect(config.stale_mode).to eq(:error)
-      expect(config.stale_mode).to be_a(Symbol)
+    it 'uses symbols for staleness' do
+      config = described_class.new(staleness: :error)
+      expect(config.staleness).to eq(:error)
+      expect(config.staleness).to be_a(Symbol)
     end
 
     it 'uses symbols for error_mode' do
-      config = described_class.new(error_mode: :trace)
-      expect(config.error_mode).to eq(:trace)
+      config = described_class.new(error_mode: :debug)
+      expect(config.error_mode).to eq(:debug)
       expect(config.error_mode).to be_a(Symbol)
     end
 

data/spec/base_tool_spec.rb

@@ -3,41 +3,42 @@
 require 'spec_helper'
 
 RSpec.describe SimpleCovMcp::BaseTool do
-  let(:handler) { SimpleCovMcp::ErrorHandler.new(error_mode: :on, logger: test_logger) }
+  let(:handler) { SimpleCovMcp::ErrorHandler.new(error_mode: :log, logger: test_logger) }
   let(:test_logger) do
     Class.new do
       attr_reader :messages
 
-      def initialize; @messages = []; end
-      def error(msg); @messages << msg; end
+      def initialize = @messages = []
+      def error(msg) = @messages << msg
     end.new
   end
 
+  let(:orig_handler) do
+    SimpleCovMcp.error_handler
+  rescue
+    nil
+  end
+
   before do
-    @orig_handler = begin
-      SimpleCovMcp.error_handler
-    rescue StandardError
-      nil
-    end
     SimpleCovMcp.error_handler = handler
     setup_mcp_response_stub
   end
 
   after do
-    SimpleCovMcp.error_handler = @orig_handler if @orig_handler
+    SimpleCovMcp.error_handler = orig_handler if orig_handler
   end
 
   shared_examples 'friendly response and logged' do
     it 'returns friendly text' do
-      resp = described_class.handle_mcp_error(error, tool, error_mode: :on)
+      resp = described_class.handle_mcp_error(error, tool, error_mode: :log)
       expect(resp).to be_a(MCP::Tool::Response)
-      expect(resp.payload.first[:text]).to match(expected_pattern)
+      expect(resp.payload.first['text']).to match(expected_pattern)
     end
 
     it 'respects error_mode :off' do
       resp = described_class.handle_mcp_error(error, tool, error_mode: :off)
       expect(resp).to be_a(MCP::Tool::Response)
-      expect(resp.payload.first[:text]).to match(expected_pattern)
+      expect(resp.payload.first['text']).to match(expected_pattern)
     end
   end
 
@@ -46,7 +47,8 @@ RSpec.describe SimpleCovMcp::BaseTool do
     let(:tool) { 'coverage_summary' }
     let(:expected_pattern) { /Error: invalid args/ }
     let(:log_fragment) { 'invalid args' }
-    include_examples 'friendly response and logged'
+
+    it_behaves_like 'friendly response and logged'
   end
 
   context 'with standard error' do
@@ -54,6 +56,7 @@ RSpec.describe SimpleCovMcp::BaseTool do
     let(:tool) { 'coverage_raw' }
     let(:expected_pattern) { /Error: .*File not found: missing.rb/ }
     let(:log_fragment) { 'File not found' }
-    include_examples 'friendly response and logged'
+
+    it_behaves_like 'friendly response and logged'
   end
 end

data/spec/cli/show_default_report_spec.rb

@@ -9,13 +9,13 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
   before do
     cli.config.root = root
     cli.config.resultset = 'coverage'
-    cli.config.stale_mode = :off
+    cli.config.staleness = :off
     cli.config.tracked_globs = nil
   end
 
   describe '#show_default_report' do
     it 'prints JSON summary using relativized payload when json mode is enabled' do
-      cli.config.json = true
+      cli.config.format = :json
 
       output = nil
       silence_output do |stdout, _stderr|

data/spec/cli_enumerated_options_spec.rb

@@ -18,18 +18,22 @@ RSpec.describe 'CLI enumerated option parsing' do
         expected: :descending },
 
       { argv: ['--source', 'f', 'summary', 'lib/foo.rb'], accessor: :source_mode, expected: :full },
-      { argv: ['--source=u', 'summary', 'lib/foo.rb'], accessor: :source_mode,
+      { argv: ['--source', 'u', 'summary', 'lib/foo.rb'], accessor: :source_mode,
         expected: :uncovered },
-      { argv: ['--source=full', 'summary', 'lib/foo.rb'], accessor: :source_mode, expected: :full },
-      { argv: ['--source=uncovered', 'summary', 'lib/foo.rb'], accessor: :source_mode,
+      { argv: ['--source', 'full', 'summary', 'lib/foo.rb'], accessor: :source_mode,
+        expected: :full },
+      { argv: ['--source', 'uncovered', 'summary', 'lib/foo.rb'], accessor: :source_mode,
         expected: :uncovered },
 
-      { argv: ['-S', 'e', 'list'], accessor: :stale_mode, expected: :error },
-      { argv: ['-S', 'o', 'list'], accessor: :stale_mode, expected: :off },
+      { argv: ['-S', 'e', 'list'], accessor: :staleness, expected: :error },
+      { argv: ['-S', 'o', 'list'], accessor: :staleness, expected: :off },
+      { argv: ['--staleness', 'e', 'list'], accessor: :staleness, expected: :error },
+      { argv: ['--staleness', 'o', 'list'], accessor: :staleness, expected: :off },
 
       { argv: ['--error-mode', 'off', 'list'], accessor: :error_mode, expected: :off },
-      { argv: ['--error-mode', 'on', 'list'], accessor: :error_mode, expected: :on },
-      { argv: ['--error-mode', 't', 'list'], accessor: :error_mode, expected: :trace }
+      { argv: ['--error-mode', 'o', 'list'], accessor: :error_mode, expected: :off },
+      { argv: ['--error-mode', 'log', 'list'], accessor: :error_mode, expected: :log },
+      { argv: ['--error-mode', 'debug', 'list'], accessor: :error_mode, expected: :debug }
     ]
 
     cases.each do |c|
@@ -43,9 +47,12 @@ RSpec.describe 'CLI enumerated option parsing' do
   describe 'rejects invalid values' do
     invalid_cases = [
       { argv: ['--sort-order', 'asc', 'list'] },
-      { argv: ['--source=x', 'summary', 'lib/foo.rb'] },
+      { argv: ['--source', 'x', 'summary', 'lib/foo.rb'] },
       { argv: ['-S', 'x', 'list'] },
-      { argv: ['--error-mode', 'bad', 'list'] }
+      { argv: ['--staleness', 'x', 'list'] },
+      { argv: ['--error-mode', 'bad', 'list'] },
+      { argv: ['--error-mode', 'on', 'list'] },
+      { argv: ['--error-mode', 'trace', 'list'] }
     ]
 
     invalid_cases.each do |c|
@@ -64,5 +71,20 @@ RSpec.describe 'CLI enumerated option parsing' do
       expect(status).to eq(1)
       expect(err).to include('invalid argument')
     end
+
+    it 'exits 1 when --staleness is provided without a value' do
+      _out, err, status = run_cli_with_status('--staleness', 'list')
+      expect(status).to eq(1)
+      expect(err).to include('invalid argument')
+    end
+
+    it 'exits 1 when --source is provided without a value' do
+      _out, err, status = run_cli_with_status('--source', 'summary', 'lib/foo.rb')
+      expect(status).to eq(1)
+      # Depending on OptParse implementation for required argument, it might say "missing argument"
+      # But usually it consumes next arg. If 'summary' is consumed as argument for source:
+      # normalize_source_mode('summary') -> raises InvalidArgument.
+      expect(err).to include('invalid argument')
+    end
   end
 end

data/spec/cli_error_spec.rb

@@ -9,9 +9,11 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
     out, err, status = run_cli_with_status('--help')
     expect(status).to eq(0)
     expect(out).to match(/Usage:.*simplecov-mcp/)
-    expect(out).to include('Repository: https://github.com/keithrbennett/simplecov-mcp')
+    expect(out).to include(
+      'Repository: https://github.com/keithrbennett/simplecov-mcp',
+      'Subcommands:'
+    )
     expect(out).to match(/Version:.*#{SimpleCovMcp::VERSION}/)
-    expect(out).to include('Subcommands:')
     expect(err).to eq('')
   end
 
@@ -19,7 +21,8 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
     before do
       # Build a fake model that raises the specified error from the specified method
       fake_model = Class.new do
-        def initialize(*) end
+        def initialize(*)
+        end
       end
       error_to_raise = raised_error
       fake_model.define_method(model_method) { |*| raise error_to_raise }
@@ -33,20 +36,22 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
     end
   end
 
-  context 'ENOENT mapping' do
+  context 'when mapping ENOENT' do
     let(:model_method) { :summary_for }
     let(:raised_error) { Errno::ENOENT.new('No such file or directory @ rb_sysopen - missing.rb') }
-    let(:invoke_args) { ['summary', 'lib/missing.rb', '--root', root, '--resultset', 'coverage'] }
+    let(:invoke_args) { ['--root', root, '--resultset', 'coverage', 'summary', 'lib/missing.rb'] }
     let(:expected_message) { 'File error: File not found: lib/missing.rb' }
-    include_examples 'maps error to exit 1 with message'
+
+    it_behaves_like 'maps error to exit 1 with message'
   end
 
-  context 'EACCES mapping' do
+  context 'when mapping EACCES' do
     let(:model_method) { :raw_for }
     let(:raised_error) { Errno::EACCES.new('Permission denied @ rb_sysopen - secret.rb') }
-    let(:invoke_args) { ['raw', 'lib/secret.rb', '--root', root, '--resultset', 'coverage'] }
+    let(:invoke_args) { ['--root', root, '--resultset', 'coverage', 'raw', 'lib/secret.rb'] }
     let(:expected_message) { 'Permission denied: lib/secret.rb' }
-    include_examples 'maps error to exit 1 with message'
+
+    it_behaves_like 'maps error to exit 1 with message'
   end
 
   it 'emits detailed stale coverage info and exits 1' do
@@ -54,8 +59,8 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
       File.join(root, 'lib', 'foo.rb') => { 'lines' => [1, 0, 1] }
     })
 
-    _out, err, status = run_cli_with_status('summary', 'lib/foo.rb', '--root', root, '--resultset',
-      'coverage', '--stale', 'error')
+    _out, err, status = run_cli_with_status('--root', root, '--resultset', 'coverage',
+      '--staleness', 'error', 'summary', 'lib/foo.rb')
     expect(status).to eq(1)
     expect(err).to include('Coverage data stale:')
     expect(err).to match(/File\s+- time:/)
@@ -69,8 +74,8 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
       File.join(root, 'lib', 'foo.rb') => { 'lines' => [1, 0, 1] }
     })
 
-    _out, err, status = run_cli_with_status('summary', 'lib/foo.rb', '--root', root, '--resultset',
-      'coverage', '--stale', 'off')
+    _out, err, status = run_cli_with_status('--root', root, '--resultset', 'coverage',
+      '--staleness', 'off', 'summary', 'lib/foo.rb')
     expect(status).to eq(0)
     expect(err).to eq('')
   end
@@ -80,22 +85,22 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
     # This is a regression test for the "can't convert nil into Integer" crash
     # that was previously mentioned in comments
     out, err, status = run_cli_with_status(
-      'uncovered', 'lib/foo.rb', '--root', root, '--resultset', 'coverage',
-      '--source=uncovered', '--source-context', '2', '--no-color'
+      '--root', root, '--resultset', 'coverage', '--source', 'uncovered', '--context-lines', '2',
+      '--no-color', 'uncovered', 'lib/foo.rb'
     )
 
     expect(status).to eq(0)
     expect(err).to eq('')
     expect(out).to match(/File:\s+lib\/foo\.rb/)
-    expect(out).to include('Uncovered lines: 2')
+    expect(out).to include('│')  # Table format
     expect(out).to show_source_table_or_fallback
   end
 
   it 'renders source with full mode without crashing' do
     # Additional regression test for source rendering with full mode
     out, err, status = run_cli_with_status(
-      'summary', 'lib/foo.rb', '--root', root, '--resultset', 'coverage',
-      '--source=full', '--no-color'
+      '--root', root, '--resultset', 'coverage', '--source', 'full', '--no-color',
+      'summary', 'lib/foo.rb'
     )
 
     expect(status).to eq(0)
@@ -115,8 +120,8 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
       File.rename(foo_path, temp_path) if File.exist?(foo_path)
 
       out, err, status = run_cli_with_status(
-        'summary', 'lib/foo.rb', '--root', root, '--resultset', 'coverage',
-        '--source=full', '--no-color'
+        '--root', root, '--resultset', 'coverage', '--source', 'full', '--no-color',
+        'summary', 'lib/foo.rb'
       )
 
       expect(status).to eq(0)
@@ -141,13 +146,13 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
     end
 
     it 'reports invalid enum value for --opt=value' do
-      _out, err, status = run_cli_with_status('list', '--stale=bogus')
+      _out, err, status = run_cli_with_status('--staleness=bogus', 'list')
       expect(status).to eq(1)
-      expect(err).to include('invalid argument: --stale=bogus')
+      expect(err).to include('invalid argument: --staleness=bogus')
     end
 
     it 'reports invalid enum value for --opt value' do
-      _out, err, status = run_cli_with_status('list', '--stale', 'bogus')
+      _out, err, status = run_cli_with_status('--staleness', 'bogus', 'list')
       expect(status).to eq(1)
       expect(err).to include('invalid argument: bogus')
     end
@@ -158,4 +163,22 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
       expect(err).to include('Error: invalid option: --no-such-option')
     end
   end
+
+  describe 'subcommand error handling' do
+    it 'handles generic exceptions from subcommands' do
+      # Stub the CommandFactory to return a command that raises a StandardError
+      fake_command = Class.new do
+        def initialize(_cli) = nil
+        def execute(_args) = raise(StandardError, 'Unexpected error in subcommand')
+      end
+
+      allow(SimpleCovMcp::Commands::CommandFactory).to receive(:create)
+        .and_return(fake_command.new(nil))
+
+      _out, err, status = run_cli_with_status('--root', root, '--resultset', 'coverage', 'summary',
+        'lib/foo.rb')
+      expect(status).to eq(1)
+      expect(err).to include('Unexpected error in subcommand')
+    end
+  end
 end