Move --drb runner specs into OptionParser specs with other callables

Previously the logic these tests exercise was contained in
RSpec::Core::Runner.run. Now it's been moved into a callable set by the
OptionParser, I've chosen to test it as part of the OptionParser tests.

This feels like an intermediate step, and I think I will likely end up
extracting the runner callables and testing them directly, rather than via the
OptionParser.

Author: urbanautomaton

lib/rspec/core/option_parser.rb

@@ -300,8 +300,7 @@ def self.drb_with_fallback
         lambda do |options, err, out|
           require 'rspec/core/drb'
           begin
-            DRbRunner.new(options).run(err, out)
-            return
+            return DRbRunner.new(options).run(err, out)
           rescue DRb::DRbConnError
             err.puts "No DRb server is running. Running in local process instead ..."
           end

spec/rspec/core/option_parser_spec.rb

@@ -1,3 +1,4 @@
+require 'rspec/core/drb'
 require 'rspec/core/project_initializer'
 
 module RSpec::Core
@@ -93,6 +94,76 @@ def generate_help_text
       end
     end
 
+    %w[ -X --drb ].each do |option|
+      describe option do
+        let(:parser) { Parser.new([option]) }
+        let(:options) { double(:options) }
+        let(:err) { double(:stderr, :puts => nil) }
+        let(:out) { double(:stderr, :puts => nil) }
+
+        it 'sets the `:drb` option to true' do
+          options = parser.parse
+
+          expect(options[:drb]).to be_truthy
+        end
+
+        context 'when a DRb server is running' do
+          it "builds a DRbRunner and runs the specs" do
+            drb_proxy = double(RSpec::Core::DRbRunner, :run => 0)
+            allow(RSpec::Core::DRbRunner).to receive(:new).and_return(drb_proxy)
+
+            options = parser.parse
+            exit_code = options[:runner].call(options, err, out)
+
+            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
+            options = parser.parse
+            options[:runner].call(options, err, out)
+
+            expect(err).to have_received(:puts).with(
+              "No DRb server is running. Running in local process instead ..."
+            )
+          end
+
+          it "builds a runner instance and runs the specs" do
+            options = parser.parse
+            options[:runner].call(options, err, out)
+
+            expect(RSpec::Core::Runner).to have_received(:new).with(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 |options|
+                raise RSpec::Expectations::ExpectationNotMetError
+              end
+
+              expect {
+                options = parser.parse
+                options[:runner].call(options, err, out)
+
+              }.to raise_error(RSpec::Expectations::ExpectationNotMetError) do |e|
+                expect(e.cause).to be_nil
+              end
+            end
+          end
+        end
+      end
+    end
+
     describe "--init" do
       it "initializes a project and returns a 0 exit code" do
         project_init = instance_double(ProjectInitializer)
@@ -320,6 +391,10 @@ def generate_help_text
       end
     end
 
+    describe '--bisect' do
+
+    end
+
     describe '--profile' do
       it 'sets profile_examples to true by default' do
         options = Parser.parse(%w[--profile])

spec/rspec/core/runner_spec.rb

@@ -255,67 +255,39 @@ def interrupt
     end
 
     describe ".run" do
+      let(:args) { double(:args) }
       let(:err) { StringIO.new }
       let(:out) { StringIO.new }
+      let(:options) { { } }
+      let(:configuration_options) { double(:configuration_options, :options => options) }
 
-      context "with --drb or -X" do
-        before(:each) do
-          @options = RSpec::Core::ConfigurationOptions.new(%w[--drb --drb-port 8181 --color])
-          allow(RSpec::Core::ConfigurationOptions).to receive(:new) { @options }
-        end
-
-        def run_specs
-          RSpec::Core::Runner.run(%w[ --drb ], err, out)
-        end
+      before(:each) do
+        allow(RSpec::Core::ConfigurationOptions).to receive(:new).and_return(configuration_options)
+      end
 
-        context 'and a DRb server is running' do
-          it "builds a DRbRunner and runs the specs" do
-            drb_proxy = double(RSpec::Core::DRbRunner, :run => true)
-            expect(drb_proxy).to receive(:run).with(err, out)
+      context 'when the options contain a runner callable' do
+        let(:runner) { double(:runner, :call => nil) }
+        let(:options) { { :runner => runner } }
 
-            expect(RSpec::Core::DRbRunner).to receive(:new).and_return(drb_proxy)
+        it 'invokes the runner callable' do
+          RSpec::Core::Runner.run([], err, out)
 
-            run_specs
-          end
+          expect(runner).to have_received(:call).with(configuration_options, err, out)
         end
+      end
 
-        context 'and a DRb server is not running' do
-          before(:each) do
-            expect(RSpec::Core::DRbRunner).to receive(:new).and_raise(DRb::DRbConnError)
-          end
-
-          it "outputs a message" do
-            allow(RSpec.configuration).to receive(:files_to_run) { [] }
-            expect(err).to receive(:puts).with(
-              "No DRb server is running. Running in local process instead ..."
-            )
-            run_specs
-          end
-
-          it "builds a runner instance and runs the specs" do
-            process_proxy = double(RSpec::Core::Runner, :run => 0)
-            expect(process_proxy).to receive(:run).with(err, out)
-
-            expect(RSpec::Core::Runner).to receive(:new).and_return(process_proxy)
+      context 'when no runner callable is set' do
+        it 'instantiates a Runner instance and runs it' do
+          process_proxy = double(RSpec::Core::Runner, :run => 0)
+          allow(RSpec::Core::Runner).to receive(:new).and_return(process_proxy)
 
-            run_specs
-          end
+          RSpec::Core::Runner.run([], err, out)
 
-          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 |options|
-                raise RSpec::Expectations::ExpectationNotMetError
-              end
-
-              expect {
-                Runner.run([], StringIO.new, StringIO.new)
-              }.to raise_error(RSpec::Expectations::ExpectationNotMetError) do |e|
-                expect(e.cause).to be_nil
-              end
-            end
-          end
+          expect(RSpec::Core::Runner).to have_received(:new)
+          expect(process_proxy).to have_received(:run).with(err, out)
         end
       end
+
     end
 
     context "when run" do