rspec-core 3.0.0.beta1 → 3.0.0.beta2

data/spec/rspec/core/drb_command_line_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 require 'rspec/core/drb_command_line'
 
-describe "::DRbCommandLine", :type => :drb, :unless => RUBY_PLATFORM == 'java' do
+RSpec.describe "::DRbCommandLine", :type => :drb, :unless => RUBY_PLATFORM == 'java' do
   let(:config) { RSpec::Core::Configuration.new }
   let(:out)    { StringIO.new }
   let(:err)    { StringIO.new }
@@ -13,9 +13,7 @@ describe "::DRbCommandLine", :type => :drb, :unless => RUBY_PLATFORM == 'java' d
   end
 
   def config_options(*args)
-    options = RSpec::Core::ConfigurationOptions.new(args)
-    options.parse_options
-    options
+    RSpec::Core::ConfigurationOptions.new(args)
   end
 
   context "without server running" do
@@ -65,12 +63,12 @@ describe "::DRbCommandLine", :type => :drb, :unless => RUBY_PLATFORM == 'java' d
     end
   end
 
-  context "with server running" do
+  context "with server running", :slow do
     class SimpleDRbSpecServer
       def self.run(argv, err, out)
         options = RSpec::Core::ConfigurationOptions.new(argv)
-        options.parse_options
-        RSpec::Core::CommandLine.new(options, RSpec::Core::Configuration.new).run(err, out)
+        config = RSpec::Core::Configuration.new
+        RSpec::Core::CommandLine.new(options, config).run(err, out)
       end
     end
 

data/spec/rspec/core/drb_options_spec.rb

@@ -1,12 +1,12 @@
 require "spec_helper"
 require 'rspec/core/drb_options'
 
-describe RSpec::Core::DrbOptions, :isolated_directory => true, :isolated_home => true do
+RSpec.describe RSpec::Core::DrbOptions, :isolated_directory => true, :isolated_home => true do
   include ConfigOptionsHelper
 
   describe "#drb_argv" do
     it "preserves extra arguments" do
-      File.stub(:exist?) { false }
+      allow(File).to receive(:exist?) { false }
       expect(config_options_object(*%w[ a --drb b --color c ]).drb_argv).to match_array %w[ --color a b c ]
     end
 

data/spec/rspec/core/dsl_spec.rb

@@ -1,22 +1,86 @@
 require 'spec_helper'
+require 'rspec/support/spec/in_sub_process'
 
 main = self
 
-describe "The RSpec DSL" do
-  methods = [
-    :describe,
-    :share_examples_for,
-    :shared_examples_for,
-    :shared_examples,
-    :shared_context,
-  ]
-
-  methods.each do |method_name|
-    describe "##{method_name}" do
-      it "is not added to every object in the system" do
-        expect(main).to respond_to(method_name)
-        expect(Module.new).to respond_to(method_name)
-        expect(Object.new).not_to respond_to(method_name)
+RSpec.describe "The RSpec DSL" do
+  include RSpec::Support::InSubProcess
+
+  shared_examples_for "dsl methods" do |*method_names|
+    context "when expose_dsl_globally is enabled" do
+      def enable
+        in_sub_process do
+          changing_expose_dsl_globally do
+            RSpec.configuration.expose_dsl_globally = true
+            expect(RSpec.configuration.expose_dsl_globally?).to eq true
+          end
+
+          yield
+        end
+      end
+
+      it 'makes them only available off of `RSpec`, `main` and modules' do
+        enable do
+          expect(::RSpec).to respond_to(*method_names)
+          expect(main).to respond_to(*method_names)
+          expect(Module.new).to respond_to(*method_names)
+
+          expect(Object.new).not_to respond_to(*method_names)
+        end
+      end
+    end
+
+    context "when expose_dsl_globally is disabled" do
+      def disable
+        in_sub_process do
+          changing_expose_dsl_globally do
+            RSpec.configuration.expose_dsl_globally = false
+            expect(RSpec.configuration.expose_dsl_globally?).to eq false
+          end
+
+          yield
+        end
+      end
+
+      it 'makes them only available off of `RSpec`' do
+        disable do
+          expect(::RSpec).to respond_to(*method_names)
+
+          expect(main).not_to respond_to(*method_names)
+          expect(Module.new).not_to respond_to(*method_names)
+          expect(Object.new).not_to respond_to(*method_names)
+        end
+      end
+    end
+  end
+
+  describe "built in DSL methods" do
+    include_examples "dsl methods",
+      :describe, :context,
+      :share_examples_for, :shared_examples_for, :shared_examples, :shared_context do
+
+      def changing_expose_dsl_globally
+        yield
+      end
+    end
+  end
+
+  describe "custom example group aliases" do
+    context "when adding aliases before exposing the DSL globally" do
+      include_examples "dsl methods", :detail do
+        def changing_expose_dsl_globally
+          RSpec.configuration.alias_example_group_to(:detail)
+          yield
+        end
+      end
+    end
+
+    context "when adding aliases after exposing the DSL globally" do
+      include_examples "dsl methods", :detail do
+        def changing_expose_dsl_globally
+          yield
+          RSpec.configuration.alias_example_group_to(:detail)
+        end
       end
     end
   end

data/spec/rspec/core/example_group_spec.rb

@@ -12,7 +12,7 @@ class SelfObserver
 end
 
 module RSpec::Core
-  describe ExampleGroup do
+  RSpec.describe ExampleGroup do
     it_behaves_like "metadata hash builder" do
       def metadata_hash(*args)
         group = ExampleGroup.describe('example description', *args)
@@ -83,8 +83,8 @@ module RSpec::Core
         expect(groups[1]).to have_class_const("Collision_2")
         expect(groups[8]).to have_class_const("Collision_9")
 
-        if RUBY_VERSION.to_f > 1.8
-          # on 1.8.7, "Collision_9".next => "Collisioo_0"
+        if RUBY_VERSION.to_f > 1.8 && !(defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx')
+          # on 1.8.7, rbx "Collision_9".next => "Collisioo_0"
           expect(groups[9]).to have_class_const("Collision_10")
         end
       end
@@ -282,12 +282,12 @@ module RSpec::Core
           before do
             filter_manager = FilterManager.new
             filter_manager.include filter_metadata
-            world.stub(:filter_manager => filter_manager)
+            allow(world).to receive_messages(:filter_manager => filter_manager)
           end
 
           it "includes examples in groups matching filter" do
             group = ExampleGroup.describe("does something", spec_metadata)
-            group.stub(:world) { world }
+            allow(group).to receive(:world) { world }
             all_examples = [ group.example("first"), group.example("second") ]
 
             expect(group.filtered_examples).to eq(all_examples)
@@ -295,7 +295,7 @@ module RSpec::Core
 
           it "includes examples directly matching filter" do
             group = ExampleGroup.describe("does something")
-            group.stub(:world) { world }
+            allow(group).to receive(:world) { world }
             filtered_examples = [
               group.example("first", spec_metadata),
               group.example("second", spec_metadata)
@@ -310,12 +310,12 @@ module RSpec::Core
           before do
             filter_manager = FilterManager.new
             filter_manager.exclude filter_metadata
-            world.stub(:filter_manager => filter_manager)
+            allow(world).to receive_messages(:filter_manager => filter_manager)
           end
 
           it "excludes examples in groups matching filter" do
             group = ExampleGroup.describe("does something", spec_metadata)
-            group.stub(:world) { world }
+            allow(group).to receive(:world) { world }
             [ group.example("first"), group.example("second") ]
 
             expect(group.filtered_examples).to be_empty
@@ -323,7 +323,7 @@ module RSpec::Core
 
           it "excludes examples directly matching filter" do
             group = ExampleGroup.describe("does something")
-            group.stub(:world) { world }
+            allow(group).to receive(:world) { world }
             [
               group.example("first", spec_metadata),
               group.example("second", spec_metadata)
@@ -404,7 +404,7 @@ module RSpec::Core
       context "with no filters" do
         it "returns all" do
           group = ExampleGroup.describe
-          group.stub(:world) { world }
+          allow(group).to receive(:world) { world }
           example = group.example("does something")
           expect(group.filtered_examples).to eq([example])
         end
@@ -414,9 +414,9 @@ module RSpec::Core
         it "returns none" do
           filter_manager = FilterManager.new
           filter_manager.include :awesome => false
-          world.stub(:filter_manager => filter_manager)
+          allow(world).to receive_messages(:filter_manager => filter_manager)
           group = ExampleGroup.describe
-          group.stub(:world) { world }
+          allow(group).to receive(:world) { world }
           group.example("does something")
           expect(group.filtered_examples).to eq([])
         end
@@ -562,6 +562,52 @@ module RSpec::Core
     end
 
     describe "#before, after, and around hooks" do
+      describe "scope aliasing" do
+        it "aliases the `:context` hook scope to `:all` for before-hooks" do
+          group = ExampleGroup.describe
+          order = []
+          group.before(:context) { order << :before_context }
+          group.example("example") { order << :example }
+          group.example("example") { order << :example }
+
+          group.run
+          expect(order).to eq([:before_context, :example, :example])
+        end
+
+        it "aliases the `:example` hook scope to `:each` for before-hooks" do
+          group = ExampleGroup.describe
+          order = []
+          group.before(:example) { order << :before_example }
+          group.example("example") { order << :example }
+          group.example("example") { order << :example }
+
+          group.run
+          expect(order).to eq([:before_example, :example, :before_example, :example])
+        end
+
+        it "aliases the `:context` hook scope to `:all` for after-hooks" do
+          group = ExampleGroup.describe
+          order = []
+          group.example("example") { order << :example }
+          group.example("example") { order << :example }
+          group.after(:context) { order << :after_context }
+
+          group.run
+          expect(order).to eq([:example, :example, :after_context])
+        end
+
+        it "aliases the `:example` hook scope to `:each` for after-hooks" do
+          group = ExampleGroup.describe
+          order = []
+          group.example("example") { order << :example }
+          group.example("example") { order << :example }
+          group.after(:example) { order << :after_example }
+
+          group.run
+          expect(order).to eq([:example, :after_example, :example, :after_example])
+        end
+      end
+
       it "runs the before alls in order" do
         group = ExampleGroup.describe
         order = []
@@ -792,7 +838,7 @@ module RSpec::Core
 
         before(:each) do
           hooks_run = []
-          RSpec.configuration.reporter.stub(:message)
+          allow(RSpec.configuration.reporter).to receive(:message)
         end
 
         let(:group) do
@@ -812,8 +858,8 @@ module RSpec::Core
         end
 
         it "rescues any error(s) and prints them out" do
-          RSpec.configuration.reporter.should_receive(:message).with(/An error in an after\(:all\) hook/)
-          RSpec.configuration.reporter.should_receive(:message).with(/A different hook raising an error/)
+          expect(RSpec.configuration.reporter).to receive(:message).with(/An error in an after\(:all\) hook/)
+          expect(RSpec.configuration.reporter).to receive(:message).with(/A different hook raising an error/)
           group.run
         end
 
@@ -842,30 +888,198 @@ module RSpec::Core
       end
     end
 
-    %w[pending xit xspecify xexample].each do |method_name|
-      describe "::#{method_name}" do
-        before do
-          @group = ExampleGroup.describe
-          @group.send(method_name, "is pending") { }
+    describe ".pending" do
+      let(:group) { ExampleGroup.describe { pending { fail } } }
+
+      it "generates a pending example" do
+        group.run
+        expect(group.examples.first).to be_pending
+      end
+
+      it "sets the pending message" do
+        group.run
+        expect(group.examples.first.metadata[:execution_result][:pending_message]).to eq(RSpec::Core::Pending::NO_REASON_GIVEN)
+      end
+    end
+
+    describe "pending with metadata" do
+      let(:group) { ExampleGroup.describe {
+        example("unimplemented", :pending => true) { fail }
+      } }
+
+      it "generates a pending example" do
+        group.run
+        expect(group.examples.first).to be_pending
+      end
+
+      it "sets the pending message" do
+        group.run
+        expect(group.examples.first.metadata[:execution_result][:pending_message]).to eq(RSpec::Core::Pending::NO_REASON_GIVEN)
+      end
+    end
+
+    describe "pending with message in metadata" do
+      let(:group) { ExampleGroup.describe {
+        example("unimplemented", :pending => 'not done') { fail }
+      } }
+
+      it "generates a pending example" do
+        group.run
+        expect(group.examples.first).to be_pending
+      end
+
+      it "sets the pending message" do
+        group.run
+        expect(group.examples.first.metadata[:execution_result][:pending_message]).to eq("not done")
+      end
+    end
+
+    describe ".skip" do
+      let(:group) { ExampleGroup.describe { skip("skip this") { } } }
+
+      it "generates a skipped example" do
+        group.run
+        expect(group.examples.first).to be_skipped
+      end
+
+      it "sets the pending message" do
+        group.run
+        expect(group.examples.first.metadata[:execution_result][:pending_message]).to eq(RSpec::Core::Pending::NO_REASON_GIVEN)
+      end
+    end
+
+    describe "skip with metadata" do
+      let(:group) { ExampleGroup.describe {
+        example("skip this", :skip => true) { }
+      } }
+
+      it "generates a skipped example" do
+        group.run
+        expect(group.examples.first).to be_skipped
+      end
+
+      it "sets the pending message" do
+        group.run
+        expect(group.examples.first.metadata[:execution_result][:pending_message]).to eq(RSpec::Core::Pending::NO_REASON_GIVEN)
+      end
+    end
+
+    describe "skip with message in metadata" do
+      let(:group) { ExampleGroup.describe {
+        example("skip this", :skip => 'not done') { }
+      } }
+
+      it "generates a skipped example" do
+        group.run
+        expect(group.examples.first).to be_skipped
+      end
+
+      it "sets the pending message" do
+        group.run
+        expect(group.examples.first.metadata[:execution_result][:pending_message]).to eq('not done')
+      end
+    end
+
+    %w[xit xspecify xexample].each do |method_name|
+      describe ".#{method_name}" do
+        let(:group) { ExampleGroup.describe.tap {|x|
+          x.send(method_name, "is pending") { }
+        }}
+
+        it "generates a skipped example" do
+          group.run
+          expect(group.examples.first).to be_skipped
         end
 
-        it "generates a pending example" do
-          @group.run
-          expect(@group.examples.first).to be_pending
+        it "sets the pending message" do
+          group.run
+          expect(group.examples.first.metadata[:execution_result][:pending_message]).to eq("Temporarily skipped with #{method_name}")
         end
+      end
+    end
 
-        it "sets the pending message", :if => method_name == 'pending' do
-          @group.run
-          expect(@group.examples.first.metadata[:execution_result][:pending_message]).to eq(RSpec::Core::Pending::NO_REASON_GIVEN)
+    %w[ xdescribe xcontext ].each do |method_name|
+      describe ".#{method_name}" do
+        def extract_execution_results(group)
+          group.examples.map do |ex|
+            ex.metadata.fetch(:execution_result)
+          end
         end
 
-        it "sets the pending message", :unless => method_name == 'pending' do
-          @group.run
-          expect(@group.examples.first.metadata[:execution_result][:pending_message]).to eq("Temporarily disabled with #{method_name}")
+        it 'generates a pending example group' do
+          group = ExampleGroup.send(method_name) do
+            it("passes") { }
+            it("fails")  { expect(2).to eq(3) }
+          end
+          group.run
+
+          expect(extract_execution_results(group)).to match([
+            a_hash_including(
+              :status => "pending",
+              :pending_message => "Temporarily skipped with #{method_name}"
+            )
+          ] * 2)
         end
       end
     end
 
+    %w[ fdescribe fcontext ].each do |method_name|
+      describe ".#{method_name}" do
+        def executed_examples_of(group)
+          examples = group.examples.select { |ex| ex.metadata[:execution_result][:started_at] }
+          group.children.inject(examples) { |exs, child| exs + executed_examples_of(child) }
+        end
+
+        [:focus, :focused].each do |metadata|
+          it "generates an example group that can be filtered with :#{metadata}" do
+            RSpec.configuration.filter_run metadata
+
+            parent_group = ExampleGroup.describe do
+              describe "not focused" do
+                example("not focused example") { }
+              end
+
+              send(method_name, "focused") do
+                example("focused example") { }
+              end
+            end
+
+            parent_group.run
+
+            executed_descriptions = executed_examples_of(parent_group).map(&:description)
+            expect(executed_descriptions).to eq(["focused example"])
+          end
+        end
+      end
+    end
+
+    describe "setting pending metadata in parent" do
+      def extract_execution_results(group)
+        group.examples.map do |ex|
+          ex.metadata.fetch(:execution_result)
+        end
+      end
+
+      it 'marks every example as pending' do
+        group = ExampleGroup.describe(:pending => true) do
+          it("passes") { }
+          it("fails", :pending => 'unimplemented')  { fail }
+        end
+        group.run
+
+        expect(extract_execution_results(group)).to match([
+          a_hash_including(
+            :status => "failed",
+            :pending_message => "No reason given"
+          ),
+          a_hash_including(
+            :status => "pending",
+            :pending_message => "unimplemented"
+          )
+        ])
+      end
+    end
+
     describe "adding examples" do
 
       it "allows adding an example using 'it'" do
@@ -925,7 +1139,7 @@ module RSpec::Core
           example('ex 1') { expect(1).to eq(1) }
           example('ex 2') { expect(1).to eq(1) }
         end
-        group.stub(:filtered_examples) { group.examples }
+        allow(group).to receive(:filtered_examples) { group.examples }
         expect(group.run(reporter)).to be_truthy
       end
 
@@ -934,7 +1148,7 @@ module RSpec::Core
           example('ex 1') { expect(1).to eq(1) }
           example('ex 2') { expect(1).to eq(2) }
         end
-        group.stub(:filtered_examples) { group.examples }
+        allow(group).to receive(:filtered_examples) { group.examples }
         expect(group.run(reporter)).to be_falsey
       end
 
@@ -943,9 +1157,9 @@ module RSpec::Core
           example('ex 1') { expect(1).to eq(2) }
           example('ex 2') { expect(1).to eq(1) }
         end
-        group.stub(:filtered_examples) { group.examples }
+        allow(group).to receive(:filtered_examples) { group.examples }
         group.filtered_examples.each do |example|
-          example.should_receive(:run)
+          expect(example).to receive(:run)
         end
         expect(group.run(reporter)).to be_falsey
       end
@@ -1031,7 +1245,7 @@ module RSpec::Core
       context "with fail_fast? => true" do
         let(:group) do
           group = RSpec::Core::ExampleGroup.describe
-          group.stub(:fail_fast?) { true }
+          allow(group).to receive(:fail_fast?) { true }
           group
         end
 
@@ -1058,18 +1272,18 @@ module RSpec::Core
         let(:group) { RSpec::Core::ExampleGroup.describe }
 
         before do
-          RSpec.stub(:wants_to_quit) { true }
-          RSpec.stub(:clear_remaining_example_groups)
+          allow(RSpec).to receive(:wants_to_quit) { true }
+          allow(RSpec).to receive(:clear_remaining_example_groups)
         end
 
         it "returns without starting the group" do
-          reporter.should_not_receive(:example_group_started)
+          expect(reporter).not_to receive(:example_group_started)
           group.run(reporter)
         end
 
         context "at top level" do
           it "purges remaining groups" do
-            RSpec.should_receive(:clear_remaining_example_groups)
+            expect(RSpec).to receive(:clear_remaining_example_groups)
             group.run(reporter)
           end
         end
@@ -1077,7 +1291,7 @@ module RSpec::Core
         context "in a nested group" do
           it "does not purge remaining groups" do
             nested_group = group.describe
-            RSpec.should_not_receive(:clear_remaining_example_groups)
+            expect(RSpec).not_to receive(:clear_remaining_example_groups)
             nested_group.run(reporter)
           end
         end