rspec-core 2.99.2 → 3.0.0.beta1

data/spec/rspec/core/drb_command_line_spec.rb

@@ -22,6 +22,8 @@ describe "::DRbCommandLine", :type => :drb, :unless => RUBY_PLATFORM == 'java' d
     it "raises an error" do
       expect { command_line.run(err, out) }.to raise_error(DRb::DRbConnError)
     end
+
+    after { DRb.stop_service }
   end
 
   describe "--drb-port" do

data/spec/rspec/core/dsl_spec.rb

@@ -9,7 +9,6 @@ describe "The RSpec DSL" do
     :shared_examples_for,
     :shared_examples,
     :shared_context,
-    :share_as
   ]
 
   methods.each do |method_name|

data/spec/rspec/core/example_group_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require 'spec_helper'
 
 class SelfObserver
@@ -27,37 +28,185 @@ module RSpec::Core
       end
     end
 
-    context 'when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to false' do
-      before(:each) do
-        allow_deprecation
-        RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = false }
+    it 'does not treat the first argument as a metadata key even if it is a symbol' do
+      group = ExampleGroup.describe(:symbol)
+      expect(group.metadata).not_to include(:symbol)
+    end
+
+    it 'treats the first argument as part of the description when it is a symbol' do
+      group = ExampleGroup.describe(:symbol)
+      expect(group.description).to eq("symbol")
+    end
+
+    describe "constant naming" do
+      RSpec::Matchers.define :have_class_const do |class_name|
+        match do |group|
+          group.name == "RSpec::ExampleGroups::#{class_name}" &&
+          group == class_name.split('::').inject(RSpec::ExampleGroups) do |mod, name|
+            mod.const_get(name)
+          end
+        end
+      end
+
+      it 'gives groups friendly human readable class names' do
+        stub_const("MyGem::Klass", Class.new)
+        parent = ExampleGroup.describe(MyGem::Klass)
+        expect(parent).to have_class_const("MyGemKlass")
       end
 
-      it 'processes string args as part of the description' do
-        group = ExampleGroup.describe("some", "separate", "strings")
-        expect(group.description).to eq("some separate strings")
+      it 'nests constants to match the group nesting' do
+        grandparent = ExampleGroup.describe("The grandparent")
+        parent      = grandparent.describe("the parent")
+        child       = parent.describe("the child")
+
+        expect(parent).to have_class_const("TheGrandparent::TheParent")
+        expect(child).to have_class_const("TheGrandparent::TheParent::TheChild")
+      end
+
+      it 'removes non-ascii characters from the const name since some rubies barf on that' do
+        group = ExampleGroup.describe("A chinese character: 们")
+        expect(group).to have_class_const("AChineseCharacter")
       end
 
-      it 'processes symbol args as part of the description' do
-        Kernel.stub(:warn) # to silence Symbols as args warning
-        group = ExampleGroup.describe(:some, :separate, :symbols)
-        expect(group.description).to eq("some separate symbols")
+      it 'prefixes the const name with "Nested" if needed to make a valid const' do
+        expect {
+          ExampleGroup.const_set("1B", Object.new)
+        }.to raise_error(NameError)
+
+        group = ExampleGroup.describe("1B")
+        expect(group).to have_class_const("Nested1B")
+      end
+
+      it 'disambiguates name collisions by appending a number' do
+        groups = 10.times.map { ExampleGroup.describe("Collision") }
+        expect(groups[0]).to have_class_const("Collision")
+        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"
+          expect(groups[9]).to have_class_const("Collision_10")
+        end
+      end
+
+      it 'identifies unnamed groups as "Anonymous"' do
+        # Wrap the anonymous group is a uniquely named one,
+        # so the presence of another anonymous group in our
+        # test suite doesn't cause an unexpected number
+        # to be appended.
+        group    = ExampleGroup.describe("name of unnamed group")
+        subgroup = group.describe
+        expect(subgroup).to have_class_const("NameOfUnnamedGroup::Anonymous")
+      end
+
+      it 'assigns the const before evaling the group so error messages include the name' do
+        expect {
+          ExampleGroup.describe("Calling an undefined method") { foo }
+        }.to raise_error(/ExampleGroups::CallingAnUndefinedMethod/)
       end
     end
 
-    context 'when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to true' do
-      let(:group) { ExampleGroup.describe(:symbol) }
+    describe "ordering" do
+      context "when tagged with `:order => :defined`" do
+        it 'orders the subgroups and examples in defined order regardless of global order' do
+          RSpec.configuration.order = :random
 
-      before(:each) do
-        RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = true }
+          run_order = []
+          group = ExampleGroup.describe "outer", :order => :defined do
+            context "subgroup 1" do
+              example { run_order << :g1_e1 }
+              example { run_order << :g1_e2 }
+            end
+
+            context "subgroup 2" do
+              example { run_order << :g2_e1 }
+              example { run_order << :g2_e2 }
+            end
+          end
+
+          group.run
+          expect(run_order).to eq([:g1_e1, :g1_e2, :g2_e1, :g2_e2])
+        end
       end
 
-      it 'does not treat the first argument as a metadata key even if it is a symbol' do
-        expect(group.metadata).not_to include(:symbol)
+      context "when tagged with an unrecognized ordering" do
+        let(:run_order) { [] }
+        let(:definition_line) { __LINE__ + 4 }
+        let(:group) do
+          order = self.run_order
+
+          ExampleGroup.describe "group", :order => :unrecognized do
+            example { order << :ex_1 }
+            example { order << :ex_2 }
+          end
+        end
+
+        before do
+          RSpec.configuration.register_ordering(:global, &:reverse)
+          allow(group).to receive(:warn)
+        end
+
+        it 'falls back to the global ordering' do
+          group.run
+          expect(run_order).to eq([:ex_2, :ex_1])
+        end
+
+        it 'prints a warning so users are notified of their mistake' do
+          warning = nil
+          allow(group).to receive(:warn) { |msg| warning = msg }
+
+          group.run
+
+          expect(warning).to match(/unrecognized/)
+          expect(warning).to match(/#{File.basename __FILE__}:#{definition_line}/)
+        end
       end
 
-      it 'treats the first argument as part of the description when it is a symbol' do
-        expect(group.description).to eq("symbol")
+      context "when tagged with a custom ordering" do
+        def ascending_numbers
+          lambda { |g| Integer(g.description[/\d+/]) }
+        end
+
+        it 'uses the custom orderings' do
+          RSpec.configure do |c|
+            c.register_ordering :custom do |items|
+              items.sort_by(&ascending_numbers)
+            end
+          end
+
+          run_order = []
+          group = ExampleGroup.describe "outer", :order => :custom do
+            example("e2") { run_order << :e2 }
+            example("e1") { run_order << :e1 }
+
+            context "subgroup 2" do
+              example("ex 3") { run_order << :g2_e3 }
+              example("ex 1") { run_order << :g2_e1 }
+              example("ex 2") { run_order << :g2_e2 }
+            end
+
+            context "subgroup 1" do
+              example("ex 2") { run_order << :g1_e2 }
+              example("ex 1") { run_order << :g1_e1 }
+              example("ex 3") { run_order << :g1_e3 }
+            end
+
+            context "subgroup 3" do
+              example("ex 2") { run_order << :g3_e2 }
+              example("ex 3") { run_order << :g3_e3 }
+              example("ex 1") { run_order << :g3_e1 }
+            end
+          end
+
+          group.run
+
+          expect(run_order).to eq([
+            :e1,    :e2,
+            :g1_e1, :g1_e2, :g1_e3,
+            :g2_e1, :g2_e2, :g2_e3,
+            :g3_e1, :g3_e2, :g3_e3
+          ])
+        end
       end
     end
 
@@ -73,7 +222,7 @@ module RSpec::Core
         end
 
         group.run
-        expect(examples_run).to have(1).example
+        expect(examples_run.count).to eq(1)
       end
 
       context "with a failure in the top level group" do
@@ -92,7 +241,7 @@ module RSpec::Core
           end
 
           group.run
-          expect(examples_run).to have(2).examples
+          expect(examples_run.count).to eq(2)
         end
       end
 
@@ -292,7 +441,7 @@ module RSpec::Core
         context "and a string in an inner group" do
           it "is the top level constant" do
             group = ExampleGroup.describe(String) do
-              describe "some string" do
+              describe :symbol do
                 example "described_class is String" do
                   expect(described_class).to eq(String)
                 end
@@ -308,7 +457,7 @@ module RSpec::Core
             group = ExampleGroup.describe(String) do
               described_class
               metadata[:example_group][:described_class] = Object
-              describe "inner" do
+              describe :symbol do
                 example "described_class is Object" do
                   expect(described_class).to eq(Object)
                 end
@@ -332,76 +481,6 @@ module RSpec::Core
 
           expect(group.run).to be_truthy, "expected examples in group to pass"
         end
-
-        def capture_deprecation_options
-          warn_opts = nil
-          allow(RSpec.configuration.reporter).to receive(:deprecation) do |opts|
-            warn_opts = opts
-          end
-
-          yield
-
-          warn_opts
-        end
-
-        it "prints a deprecation warning since the semantics of an inner described_class are changing in RSpec 3" do
-          warn_opts = capture_deprecation_options do
-            ExampleGroup.describe(String) do
-              describe Array do
-                example { described_class }
-              end
-            end.run
-          end
-
-          expect(warn_opts[:message]).to include("#{__FILE__}:#{__LINE__ - 5}")
-          expect(warn_opts[:message]).to include("described_class")
-        end
-
-        it "prints a deprecation warning since the semantics of an inner described symbol are changing in RSpec 3" do
-          warn_opts = capture_deprecation_options do
-            ExampleGroup.describe(String) do
-              describe :method do
-                example { described_class }
-              end
-            end.run
-          end
-
-          expect(warn_opts[:message]).to include("#{__FILE__}:#{__LINE__ - 6}")
-          expect(warn_opts[:message]).to include("described_class")
-        end
-
-        it "prints a deprecation even when `described_class` has already been referenced in the outer group" do
-          warn_opts = capture_deprecation_options do
-            outer_dc = inner_dc = nil
-            ExampleGroup.describe(String) do
-              outer_dc = described_class
-              describe Array do
-                example { inner_dc = described_class }
-              end
-            end.run
-
-            expect(outer_dc).to eq(String)
-            expect(inner_dc).to eq(String)
-          end
-
-          expect(warn_opts[:message]).to include("#{__FILE__}:#{__LINE__ - 8}")
-          expect(warn_opts[:message]).to include("described_class")
-        end
-
-        it "does not print a deprecation warning when the inner example group has no description args" do
-          dc = :unset
-          deprecations = []
-          allow(RSpec).to receive(:warn_deprecation) { |msg| deprecations << msg }
-
-          ExampleGroup.describe(String) do
-            describe do
-              example { dc = described_class }
-            end
-          end.run
-
-          expect(dc).to be(String)
-          expect(deprecations).to eq([])
-        end
       end
 
       context "for `describe(SomeClass)` within a `describe 'some string' group" do
@@ -747,7 +826,6 @@ module RSpec::Core
       it "has access to example options within before(:each)" do
         group = ExampleGroup.describe
         option = nil
-        expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /options/)
         group.before(:each) {|ex| option = ex.options[:data] }
         group.example("no-op", :data => :sample) { }
         group.run
@@ -757,7 +835,6 @@ module RSpec::Core
       it "has access to example options within after(:each)" do
         group = ExampleGroup.describe
         option = nil
-        expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /options/)
         group.after(:each) {|ex| option = ex.options[:data] }
         group.example("no-op", :data => :sample) { }
         group.run
@@ -765,70 +842,30 @@ module RSpec::Core
       end
     end
 
-    context 'skip in metadata' do
-      let(:group) { ExampleGroup.describe do
-          it 'is skipped', :skip => 'skip this' do
-          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") { }
         end
-      }
-
-      before { group.run }
-
-      it 'generates a pending example' do
-        expect(group.examples.first).to be_pending
-      end
-
-      it 'sets the pending message' do
-        expect(group.examples.first.metadata[:execution_result][:pending_message]).to eq('skip this')
-      end
-    end
-
-    %w[pending skip].each do |method_name|
-      describe ".#{method_name}" do
-        let(:group) { ExampleGroup.describe.tap {|x|
-          x.send(method_name, "is pending") { }
-        }}
-
-        before { group.run } 
 
         it "generates a pending example" do
-          expect(group.examples.first).to be_pending
+          @group.run
+          expect(@group.examples.first).to be_pending
         end
 
-        it "sets the pending message" do
-          expect(group.examples.first.metadata[:execution_result][:pending_message]).to eq(RSpec::Core::Pending::NO_REASON_GIVEN)
+        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)
         end
-      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") { }
-        }}
 
-        before { group.run } 
-
-        it "generates a pending example" do
-          expect(group.examples.first).to be_pending
-        end
-
-        it "sets the pending message" do
-          expect(group.examples.first.metadata[:execution_result][:pending_message]).to eq("Temporarily disabled with #{method_name}")
+        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}")
         end
       end
     end
 
-    describe '::pending' do
-      it 'shows upgrade warning' do
-        expect_warn_deprecation_with_call_site(
-          "example_group_spec.rb", __LINE__ + 3
-        )
-        group = ExampleGroup.describe
-        group.send(:pending, "is pending") { }
-      end
-    end
-
     describe "adding examples" do
 
       it "allows adding an example using 'it'" do
@@ -842,7 +879,7 @@ module RSpec::Core
         group.it("should do something 1") { }
         group.it("should do something 2") { }
         group.it("should do something 3") { }
-        expect(group).to have(3).examples
+        expect(group.examples.count).to eq(3)
       end
 
       it "maintains the example order" do
@@ -888,7 +925,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.extend(Extensions::Ordered::Examples) }
+        group.stub(:filtered_examples) { group.examples }
         expect(group.run(reporter)).to be_truthy
       end
 
@@ -897,7 +934,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.extend(Extensions::Ordered::Examples) }
+        group.stub(:filtered_examples) { group.examples }
         expect(group.run(reporter)).to be_falsey
       end
 
@@ -906,7 +943,7 @@ 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.extend(Extensions::Ordered::Examples) }
+        group.stub(:filtered_examples) { group.examples }
         group.filtered_examples.each do |example|
           example.should_receive(:run)
         end
@@ -1167,41 +1204,6 @@ module RSpec::Core
           end
           expect(group.run).to be_truthy
         end
-
-        it "warns when extra args are submitted to a zero-arity shared block", :if => RUBY_VERSION.to_f >= 1.9 do
-          group = ExampleGroup.describe
-          group.shared_examples("named this") {}
-
-          expect(group).to receive(:warn) {|message|
-            expect(message).to match(/expected 0 args/)
-            expect(message).to match(/called from #{__FILE__}:#{__LINE__ + 2}/)
-          }
-          group.send(name, "named this", "extra arg")
-        end
-
-        it "warns with usage message when 2nd arg is the name of another shared group", :if => RUBY_VERSION.to_f >= 1.9 do
-          group = ExampleGroup.describe
-          group.shared_examples("named this") {}
-          group.shared_examples("named that") {}
-
-          expect(group).to receive(:warn) {|message|
-            expect(message).to match(/shared (context|examples) supports? the name of only one example group, received \["named this", "named that"\]/)
-            expect(message).to match(/called from #{__FILE__}:#{__LINE__ + 2}/)
-          }
-          group.send(name, "named this", "named that")
-        end
-
-        it 'does not warn when the shared example group has a default arg', :if => RUBY_VERSION.to_f >= 1.9 do
-          group = ExampleGroup.describe
-
-          # 1.8.7 can't parse blocks with arg defaults, so we have to eval it
-          # to delay when it is parsed.
-          eval('group.shared_examples("named this") { |opts={}| }')
-
-          expect(group).not_to receive(:warn)
-
-          group.send(name, "named this", :foo => 1)
-        end
       end
     end
 
@@ -1210,7 +1212,7 @@ module RSpec::Core
         group = ExampleGroup.describe('fake group')
         group.shared_examples_for("thing") {}
         group.it_should_behave_like("thing")
-        expect(group).to have(1).children
+        expect(group.children.count).to eq(1)
       end
 
       it "creates a nested group for a class" do
@@ -1218,7 +1220,7 @@ module RSpec::Core
         group = ExampleGroup.describe('fake group')
         group.shared_examples_for(klass) {}
         group.it_should_behave_like(klass)
-        expect(group).to have(1).children
+        expect(group.children.count).to eq(1)
       end
 
       it "adds shared examples to nested group" do
@@ -1227,7 +1229,7 @@ module RSpec::Core
           it("does something")
         end
         shared_group = group.it_should_behave_like("thing")
-        expect(shared_group).to have(1).examples
+        expect(shared_group.examples.count).to eq(1)
       end
 
       it "adds shared instance methods to nested group" do
@@ -1313,38 +1315,5 @@ module RSpec::Core
         end.to raise_error(ArgumentError,%q|Could not find shared examples "shared stuff"|)
       end
     end
-
-    describe "deprecated methods" do
-      specify ".describes is deprecated" do
-        expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /describes/)
-        expect(self.class.describes).to eq(self.class.described_class)
-      end
-
-      specify ".display_name is deprecated" do
-        expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /display_name/)
-        expect(self.class.display_name).to eq(self.class.description)
-      end
-
-      specify ".alias_it_behaves_like_to is deprecated" do
-        expect_deprecation_with_call_site(__FILE__, __LINE__ + 2, /alias_it_behaves_like_to/)
-        expect {
-          ExampleGroup.alias_it_behaves_like_to(:it_does_something, "it does something")
-        }.to change { ExampleGroup.respond_to?(:it_does_something) }.from(false).to(true)
-      end
-
-      specify ".alias_example_to is deprecated" do
-        expect_deprecation_with_call_site(__FILE__, __LINE__ + 2, /alias_example_to/)
-        expect {
-          ExampleGroup.alias_example_to(:an_example)
-        }.to change { ExampleGroup.respond_to?(:an_example) }.from(false).to(true)
-      end
-
-      specify ".focused is deprecated" do
-        expect_deprecation_with_call_site(__FILE__, __LINE__ + 2, /focused/)
-        ExampleGroup.describe("group") do
-          focused("example") { }
-        end
-      end
-    end
   end
 end