Extract Parser::Callables to Invocations module

Previous work introduced a set of invocation callables that could be set in
the OptionParser to run instead of the default RSpec::Core::Runner. Testing
them via the the OptionParser seemed out-of-place, however, and made the test
stimulus needlessly complex.

This change extracts the invocations to their own top-level module, and tests
them separately from the OptionParser.

Author: urbanautomaton

lib/rspec/core.rb

@@ -31,6 +31,7 @@
   option_parser
   configuration_options
   runner
+  invocations
   example
   shared_example_group
   example_group

lib/rspec/core/invocations.rb

@@ -0,0 +1,63 @@
+module RSpec
+  module Core
+    module Invocations
+      def self.initialize_project
+        lambda do |*_args|
+          RSpec::Support.require_rspec_core "project_initializer"
+          ProjectInitializer.new.run
+          0
+        end
+      end
+
+      def self.drb_with_fallback
+        lambda do |options, err, out|
+          require 'rspec/core/drb'
+          begin
+            return DRbRunner.new(options).run(err, out)
+          rescue DRb::DRbConnError
+            err.puts "No DRb server is running. Running in local process instead ..."
+          end
+          RSpec::Core::Runner.new(options).run(err, out)
+        end
+      end
+
+      def self.bisect
+        lambda do |options, _err, _out|
+          RSpec::Support.require_rspec_core "bisect/coordinator"
+
+          success = Bisect::Coordinator.bisect_with(
+            options.args,
+            RSpec.configuration,
+            bisect_formatter_for(options.options[:bisect])
+          )
+
+          success ? 0 : 1
+        end
+      end
+
+      def self.print_version
+        lambda do |_options, _err, out|
+          out.puts RSpec::Core::Version::STRING
+          0
+        end
+      end
+
+      def self.print_help(parser, invalid_options)
+        lambda do |_options, _err, out|
+          # Removing the blank invalid options from the output.
+          out.puts parser.to_s.gsub(/^\s+(#{invalid_options.join('|')})\s*$\n/, '')
+          0
+        end
+      end
+
+      def self.bisect_formatter_for(argument)
+        return Formatters::BisectDebugFormatter if argument == "verbose"
+        Formatters::BisectProgressFormatter
+      end
+
+      class << self
+        private :bisect_formatter_for
+      end
+    end
+  end
+end

lib/rspec/core/option_parser.rb

@@ -70,7 +70,7 @@ def parser(options)
         parser.on('--bisect[=verbose]', 'Repeatedly runs the suite in order to isolate the failures to the ',
                   '  smallest reproducible case.') do |argument|
           options[:bisect] = argument || true
-          options[:runner] = Callables.bisect
+          options[:runner] = RSpec::Core::Invocations.bisect
         end
 
         parser.on('--[no-]fail-fast[=COUNT]', 'Abort the run after a certain number of failures (1 by default).') do |argument|
@@ -100,15 +100,15 @@ def parser(options)
 
         parser.on('-X', '--[no-]drb', 'Run examples via DRb.') do |use_drb|
           options[:drb] = use_drb
-          options[:runner] = Callables.drb_with_fallback if use_drb
+          options[:runner] = RSpec::Core::Invocations.drb_with_fallback if use_drb
         end
 
         parser.on('--drb-port PORT', 'Port to connect to the DRb server.') do |o|
           options[:drb_port] = o.to_i
         end
 
         parser.on('--init', 'Initialize your project with RSpec.') do |_cmd|
-          options[:runner] = Callables.initialize_project
+          options[:runner] = RSpec::Core::Invocations.initialize_project
         end
 
         parser.separator("\n  **** Output ****\n\n")
@@ -245,7 +245,7 @@ def parser(options)
         parser.separator("\n  **** Utility ****\n\n")
 
         parser.on('-v', '--version', 'Display the version.') do
-          options[:runner] = Callables.print_version
+          options[:runner] = RSpec::Core::Invocations.print_version
         end
 
         # These options would otherwise be confusing to users, so we forcibly
@@ -257,7 +257,7 @@ def parser(options)
         invalid_options = %w[-d --I]
 
         parser.on_tail('-h', '--help', "You're looking at it.") do
-          options[:runner] = Callables.print_help(parser, invalid_options)
+          options[:runner] = RSpec::Core::Invocations.print_help(parser, invalid_options)
         end
 
         # This prevents usage of the invalid_options.
@@ -285,62 +285,5 @@ def configure_only_failures(options)
       options[:only_failures] = true
       add_tag_filter(options, :inclusion_filter, :last_run_status, 'failed')
     end
-
-    # @private
-    module Callables
-      def self.initialize_project
-        lambda do |*_args|
-          RSpec::Support.require_rspec_core "project_initializer"
-          ProjectInitializer.new.run
-          0
-        end
-      end
-
-      def self.drb_with_fallback
-        lambda do |options, err, out|
-          require 'rspec/core/drb'
-          begin
-            return DRbRunner.new(options).run(err, out)
-          rescue DRb::DRbConnError
-            err.puts "No DRb server is running. Running in local process instead ..."
-          end
-          RSpec::Core::Runner.new(options).run(err, out)
-        end
-      end
-
-      def self.bisect
-        lambda do |options, _err, _out|
-          RSpec::Support.require_rspec_core "bisect/coordinator"
-
-          success = Bisect::Coordinator.bisect_with(
-            options.args,
-            RSpec.configuration,
-            bisect_formatter_for(options.options[:bisect])
-          )
-
-          success ? 0 : 1
-        end
-      end
-
-      def self.print_version
-        lambda do |*_args|
-          puts RSpec::Core::Version::STRING
-          0
-        end
-      end
-
-      def self.print_help(parser, invalid_options)
-        lambda do |*_args|
-          # Removing the blank invalid options from the output.
-          puts parser.to_s.gsub(/^\s+(#{invalid_options.join('|')})\s*$\n/, '')
-          0
-        end
-      end
-
-      def self.bisect_formatter_for(argument)
-        return Formatters::BisectDebugFormatter if argument == "verbose"
-        Formatters::BisectProgressFormatter
-      end
-    end
   end
 end

spec/rspec/core/invocations_spec.rb

@@ -0,0 +1,180 @@
+require 'rspec/core/drb'
+require 'rspec/core/bisect/coordinator'
+require 'rspec/core/project_initializer'
+
+module RSpec::Core
+  RSpec.describe Invocations do
+    let(:configuration_options) { instance_double(ConfigurationOptions) }
+    let(:err) { StringIO.new }
+    let(:out) { StringIO.new }
+
+    def run_invocation
+      subject.call(configuration_options, err, out)
+    end
+
+    describe '.initialize_project' do
+      subject { described_class.initialize_project }
+
+      it "initializes a project and returns a 0 exit code" do
+        project_init = instance_double(ProjectInitializer, :run => nil)
+        allow(ProjectInitializer).to receive_messages(:new => project_init)
+
+        exit_code = run_invocation
+
+        expect(project_init).to have_received(:run)
+        expect(exit_code).to eq(0)
+      end
+    end
+
+    describe '.drb_with_fallback' do
+      subject { described_class.drb_with_fallback }
+
+      context 'when a DRb server is running' do
+        it "builds a DRbRunner and runs the specs" do
+          drb_proxy = instance_double(RSpec::Core::DRbRunner, :run => 0)
+          allow(RSpec::Core::DRbRunner).to receive(:new).and_return(drb_proxy)
+
+          exit_code = run_invocation
+
+          expect(drb_proxy).to have_received(:run).with(err, out)
+          expect(exit_code).to eq(0)
+        end
+      end
+
+      context 'when a DRb server is not running' do
+        let(:runner) { instance_double(RSpec::Core::Runner, :run => 0) }
+
+        before(:each) do
+          allow(RSpec::Core::Runner).to receive(:new).and_return(runner)
+          allow(RSpec::Core::DRbRunner).to receive(:new).and_raise(DRb::DRbConnError)
+        end
+
+        it "outputs a message" do
+          run_invocation
+
+          expect(err.string).to include(
+            "No DRb server is running. Running in local process instead ..."
+          )
+        end
+
+        it "builds a runner instance and runs the specs" do
+          run_invocation
+
+          expect(RSpec::Core::Runner).to have_received(:new).with(configuration_options)
+          expect(runner).to have_received(:run).with(err, out)
+        end
+
+        if RSpec::Support::RubyFeatures.supports_exception_cause?
+          it "prevents the DRb error from being listed as the cause of expectation failures" do
+            allow(RSpec::Core::Runner).to receive(:new) do |configuration_options|
+              raise RSpec::Expectations::ExpectationNotMetError
+            end
+
+            expect {
+              run_invocation
+            }.to raise_error(RSpec::Expectations::ExpectationNotMetError) do |e|
+              expect(e.cause).to be_nil
+            end
+          end
+        end
+      end
+    end
+
+    describe '.bisect' do
+      subject { described_class.bisect }
+
+      let(:bisect) { nil }
+      let(:options) { { :bisect => bisect } }
+      let(:args) { double(:args) }
+      let(:success) { true }
+
+      before do
+        allow(configuration_options).to receive_messages(:args => args, :options => options)
+        allow(RSpec::Core::Bisect::Coordinator).to receive(:bisect_with).and_return(success)
+      end
+
+      it "starts the bisection coordinator" do
+        run_invocation
+
+        expect(RSpec::Core::Bisect::Coordinator).to have_received(:bisect_with).with(
+          args,
+          RSpec.configuration,
+          Formatters::BisectProgressFormatter
+        )
+      end
+
+      context "when the bisection is successful" do
+        it "returns 0" do
+          exit_code = run_invocation
+
+          expect(exit_code).to eq(0)
+        end
+      end
+
+      context "when the bisection is unsuccessful" do
+        let(:success) { false }
+
+        it "returns 1" do
+          exit_code = run_invocation
+
+          expect(exit_code).to eq(1)
+        end
+      end
+
+      context "and the verbose option is specified" do
+        let(:bisect) { "verbose" }
+
+        it "starts the bisection coordinator with the debug formatter" do
+          run_invocation
+
+          expect(RSpec::Core::Bisect::Coordinator).to have_received(:bisect_with).with(
+            args,
+            RSpec.configuration,
+            Formatters::BisectDebugFormatter
+          )
+        end
+      end
+    end
+
+    describe '.print_version' do
+      subject { described_class.print_version }
+
+      it "prints the version and returns a zero exit code" do
+
+        exit_code = run_invocation
+
+        expect(exit_code).to eq(0)
+        expect(out.string).to include("#{RSpec::Core::Version::STRING}\n")
+      end
+    end
+
+    describe '.print_help' do
+      let(:parser) { instance_double(OptionParser) }
+      let(:invalid_options) { %w[ -d ] }
+
+      subject { described_class.print_help(parser, invalid_options) }
+
+      before do
+        allow(parser).to receive(:to_s).and_return(<<-EOS)
+        -d
+        --bisect[=verbose]           Repeatedly runs the suite in order...
+        EOS
+      end
+
+      it "prints the CLI options and returns a zero exit code" do
+        exit_code = run_invocation
+
+        expect(exit_code).to eq(0)
+        expect(out.string).to include("--bisect")
+      end
+
+      it "won't display invalid options in the help output" do
+        useless_lines = /^\s*-d\s*$\n/
+
+        run_invocation
+
+        expect(out.string).to_not match(useless_lines)
+      end
+    end
+  end
+end