rspec-core 2.8.0.rc1 → 2.8.0.rc2

data/spec/rspec/core/example_group_spec.rb

@@ -11,7 +11,6 @@ class SelfObserver
 end
 
 module RSpec::Core
-
   describe ExampleGroup do
     it_behaves_like "metadata hash builder" do
       def metadata_hash(*args)
@@ -23,7 +22,6 @@ module RSpec::Core
     context 'when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to false' do
       before(:each) do
         RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = false }
-        Kernel.stub(:warn)
       end
 
       it 'processes string args as part of the description' do
@@ -32,6 +30,7 @@ module RSpec::Core
       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)
         group.description.should eq("some separate symbols")
       end
@@ -39,6 +38,7 @@ module RSpec::Core
 
     context 'when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to true' do
       let(:group) { ExampleGroup.describe(:symbol) }
+
       before(:each) do
         RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = true }
       end
@@ -265,17 +265,17 @@ module RSpec::Core
       end
     end
 
-    describe '#describes' do
+    describe '#described_class' do
 
       context "with a constant as the first parameter" do
         it "is that constant" do
-          ExampleGroup.describe(Object) { }.describes.should eq(Object)
+          ExampleGroup.describe(Object) { }.described_class.should eq(Object)
         end
       end
 
       context "with a string as the first parameter" do
         it "is nil" do
-          ExampleGroup.describe("i'm a computer") { }.describes.should be_nil
+          ExampleGroup.describe("i'm a computer") { }.described_class.should be_nil
         end
       end
 
@@ -284,7 +284,7 @@ module RSpec::Core
           it "is the top level constant" do
             group = ExampleGroup.describe(String) do
               describe :symbol do
-                example "describes is String" do
+                example "described_class is String" do
                   described_class.should eq(String)
                 end
               end
@@ -311,8 +311,8 @@ module RSpec::Core
     end
 
     describe '#described_class' do
-      it "is the same as describes" do
-        self.class.described_class.should eq(self.class.describes)
+      it "is the same as described_class" do
+        self.class.described_class.should eq(self.class.described_class)
       end
     end
 
@@ -618,19 +618,26 @@ module RSpec::Core
       end
     end
 
-    matcher :add_a_pending_example_with do |method_name|
-      match do |group|
-        group = ExampleGroup.describe
-        group.send(method_name, "is pending") { }
-        group.run
-        group.examples.first.should be_pending
-      end
-    end
-
     %w[pending xit xspecify xexample].each do |method_name|
-      describe "##{method_name}" do
+      describe "::#{method_name}" do
+        before do
+          @group = ExampleGroup.describe
+          @group.send(method_name, "is pending") { }
+        end
+
         it "generates a pending example" do
-          ExampleGroup.describe.should add_a_pending_example_with(method_name)
+          @group.run
+          @group.examples.first.should be_pending
+        end
+
+        it "sets the pending message", :if => method_name == 'pending' do
+          @group.run
+          @group.examples.first.metadata[:execution_result][:pending_message].should eq(RSpec::Core::Pending::NO_REASON_GIVEN)
+        end
+
+        it "sets the pending message", :unless => method_name == 'pending' do
+          @group.run
+          @group.examples.first.metadata[:execution_result][:pending_message].should eq("Temporarily disabled with #{method_name}")
         end
       end
     end
@@ -667,7 +674,7 @@ module RSpec::Core
 
       describe "A sample nested group", :nested_describe => "yep" do
         it "sets the described class to the described class of the outer most group" do
-          example.example_group.describes.should eq(ExampleGroup)
+          example.example_group.described_class.should eq(ExampleGroup)
         end
 
         it "sets the description to 'A sample nested describe'" do
@@ -893,54 +900,66 @@ module RSpec::Core
       end
     end
 
-    describe "#include_context" do
-      before do
-        shared_context "named this" do
-          def foo; 'foo'; end
+    %w[include_examples include_context].each do |name|
+      describe "##{name}" do
+        before do
+          shared_examples "named this" do
+            example("does something") {}
+          end
         end
-      end
 
-      it "includes the named context" do
-        group = ExampleGroup.describe do
-          include_context "named this"
-          it "accesses foo" do
-            foo.should eq('foo')
-          end
+        it "includes the named examples" do
+          group = ExampleGroup.describe
+          group.send(name, "named this")
+          group.examples.first.description.should eq("does something")
         end
-        group.run.should be_true
-      end
 
-      it "raises a helpful error message when shared context is not found" do
-        expect do
-          ExampleGroup.describe do
-            include_context "shared stuff"
+        it "raises a helpful error message when shared content is not found" do
+          group = ExampleGroup.describe
+          expect do
+            group.send(name, "shared stuff")
+          end.to raise_error(ArgumentError, /Could not find .* "shared stuff"/)
+        end
+
+        it "passes parameters to the shared content" do
+          passed_params = {}
+
+          shared_examples "named this with params" do |param1, param2|
+            it("has access to the given parameters") do
+              passed_params[:param1] = param1
+              passed_params[:param2] = param2
+            end
           end
-        end.to raise_error(ArgumentError,%q|Could not find shared context "shared stuff"|)
-      end
 
-    end
+          group = ExampleGroup.describe
+          group.send(name, "named this with params", :value1, :value2)
+          group.run
 
-    describe "#include_examples" do
-      before do
-        shared_examples "named this" do
-          example("does something") do
+          passed_params.should eq({ :param1 => :value1, :param2 => :value2 })
+        end
+
+        it "adds shared instance methods to the group" do
+          shared_examples "named this with params" do |param1|
+            def foo; end
           end
+          group = ExampleGroup.describe('fake group')
+          group.send(name, "named this with params", :a)
+          group.public_instance_methods.map{|m| m.to_s}.should include("foo")
         end
-      end
 
-      it "includes the named examples" do
-        group = ExampleGroup.describe do
-          include_examples "named this"
+        it "evals the shared example group only once" do
+          eval_count = 0
+          shared_examples("named this with params") { |p| eval_count += 1 }
+          group = ExampleGroup.describe('fake group')
+          group.send(name, "named this with params", :a)
+          eval_count.should eq(1)
         end
-        group.examples.first.description.should eq("does something")
-      end
 
-      it "raises a helpful error message when shared context is not found" do
-        expect do
-          ExampleGroup.describe do
-            include_examples "shared stuff"
-          end
-        end.to raise_error(ArgumentError,%q|Could not find shared examples "shared stuff"|)
+        it "warns the user that blocks are not supported when given a block" do
+          group = ExampleGroup.describe
+          group.should_receive(:warn).with(/blocks not supported for #{name}/)
+          group.send(name, "named this with block") {}
+        end
       end
     end
 
@@ -987,41 +1006,39 @@ module RSpec::Core
         shared_group.methods.map{|m| m.to_s}.should include("foo")
       end
 
-      context "given some parameters" do
-        it "passes the parameters to the shared example group" do
-          passed_params = {}
-
-          shared_examples_for("thing") do |param1, param2|
-            it("has access to the given parameters") do
-              passed_params[:param1] = param1
-              passed_params[:param2] = param2
-            end
-          end
+      it "passes parameters to the shared example group" do
+        passed_params = {}
 
-          group = ExampleGroup.describe("group") do
-            it_should_behave_like "thing", :value1, :value2
+        shared_examples_for("thing") do |param1, param2|
+          it("has access to the given parameters") do
+            passed_params[:param1] = param1
+            passed_params[:param2] = param2
           end
-          group.run
-
-          passed_params.should eq({ :param1 => :value1, :param2 => :value2 })
         end
 
-        it "adds shared instance methods to nested group" do
-          shared_examples_for("thing") do |param1|
-            def foo; end
-          end
-          group = ExampleGroup.describe('fake group')
-          shared_group = group.it_should_behave_like("thing", :a)
-          shared_group.public_instance_methods.map{|m| m.to_s}.should include("foo")
+        group = ExampleGroup.describe("group") do
+          it_should_behave_like "thing", :value1, :value2
         end
+        group.run
 
-        it "evals the shared example group only once" do
-          eval_count = 0
-          shared_examples_for("thing") { |p| eval_count += 1 }
-          group = ExampleGroup.describe('fake group')
-          group.it_should_behave_like("thing", :a)
-          eval_count.should eq(1)
+        passed_params.should eq({ :param1 => :value1, :param2 => :value2 })
+      end
+
+      it "adds shared instance methods to nested group" do
+        shared_examples_for("thing") do |param1|
+          def foo; end
         end
+        group = ExampleGroup.describe('fake group')
+        shared_group = group.it_should_behave_like("thing", :a)
+        shared_group.public_instance_methods.map{|m| m.to_s}.should include("foo")
+      end
+
+      it "evals the shared example group only once" do
+        eval_count = 0
+        shared_examples_for("thing") { |p| eval_count += 1 }
+        group = ExampleGroup.describe('fake group')
+        group.it_should_behave_like("thing", :a)
+        eval_count.should eq(1)
       end
 
       context "given a block" do

data/spec/rspec/core/example_spec.rb

@@ -29,6 +29,20 @@ describe RSpec::Core::Example, :parent_metadata => 'sample' do
       example_group.run
       example.exception.should be_nil
     end
+
+    it "returns false for pending_fixed? if not pending fixed" do
+      example = example_group.example { fail }
+      example_group.run
+      example.exception.should_not be_pending_fixed
+    end
+
+    it "returns true for pending_fixed? if pending fixed" do
+      example = example_group.example do
+        pending("fixed") {}
+      end
+      example_group.run
+      example.exception.should be_pending_fixed
+    end
   end
 
   describe "auto-generated example descriptions" do

data/spec/rspec/core/filter_manager_spec.rb

@@ -2,52 +2,112 @@ require 'spec_helper'
 
 module RSpec::Core
   describe FilterManager do
-    %w[inclusions include exclusions exclude].each_slice(2) do |type, name|
-      it "merges #{type}" do
-        filter_manager = FilterManager.new
-        filter_manager.exclusions.clear # defaults
-        filter_manager.send name, :foo => :bar
-        filter_manager.send name, :baz => :bam
-        filter_manager.send(type).should eq(:foo => :bar, :baz => :bam)
+    def opposite(name)
+      name =~ /^in/ ? name.sub(/^(in)/,'ex') : name.sub(/^(ex)/,'in')
+    end
+
+    %w[include inclusions exclude exclusions].each_slice(2) do |name, type|
+      describe "##{name}" do
+        it "merges #{type}" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send name, :foo => :bar
+          filter_manager.send name, :baz => :bam
+          filter_manager.send(type).should eq(:foo => :bar, :baz => :bam)
+        end
+
+        it "overrides previous #{type} with (via merge)" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send name, :foo => 1
+          filter_manager.send name, :foo => 2
+          filter_manager.send(type).should eq(:foo => 2)
+        end
+
+        it "deletes matching opposites" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send opposite(name), :foo => 1
+          filter_manager.send name, :foo => 2
+          filter_manager.send(type).should eq(:foo => 2)
+          filter_manager.send(opposite(type)).should be_empty
+        end
       end
 
-      it "overrides previous #{type} (via merge)" do
-        filter_manager = FilterManager.new
-        filter_manager.exclusions.clear # defaults
-        filter_manager.send name, :foo => 1
-        filter_manager.send name, :foo => 2
-        filter_manager.send(type).should eq(:foo => 2)
+      describe "##{name}!" do
+        it "replaces existing #{type}" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send name, :foo => 1, :bar => 2
+          filter_manager.send "#{name}!", :foo => 3
+          filter_manager.send(type).should eq(:foo => 3)
+        end
+
+        it "deletes matching opposites" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send opposite(name), :foo => 1
+          filter_manager.send "#{name}!", :foo => 2
+          filter_manager.send(type).should eq(:foo => 2)
+          filter_manager.send(opposite(type)).should be_empty
+        end
       end
 
-      it "ignores new #{type} if same key exists and priority is low" do
-        filter_manager = FilterManager.new
-        filter_manager.exclusions.clear # defaults
-        filter_manager.send name, :foo => 1
-        filter_manager.send name, :weak, :foo => 2
-        filter_manager.send(type).should eq(:foo => 1)
+      describe "##{name}_with_low_priority" do
+        it "ignores new #{type} if same key exists" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send name, :foo => 1
+          filter_manager.send "#{name}_with_low_priority", :foo => 2
+          filter_manager.send(type).should eq(:foo => 1)
+        end
+
+        it "ignores new #{type} if same key exists in opposite" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send opposite(name), :foo => 1
+          filter_manager.send "#{name}_with_low_priority", :foo => 1
+          filter_manager.send(type).should be_empty
+          filter_manager.send(opposite(type)).should eq(:foo => 1)
+        end
+
+        it "keeps new #{type} if same key exists in opposite but values are different" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send opposite(name), :foo => 1
+          filter_manager.send "#{name}_with_low_priority", :foo => 2
+          filter_manager.send(type).should eq(:foo => 2)
+          filter_manager.send(opposite(type)).should eq(:foo => 1)
+        end
       end
     end
 
     describe "#prune" do
+      def filterable_object_with(args = {})
+        object = double('a filterable object')
+        object.stub(:any_apply?) { |f| Metadata.new(args).any_apply?(f) }
+        object
+      end
+
       it "includes objects with tags matching inclusions" do
-        included = RSpec::Core::Metadata.new({:foo => :bar})
-        excluded = RSpec::Core::Metadata.new
+        included = filterable_object_with({:foo => :bar})
+        excluded = filterable_object_with
         filter_manager = FilterManager.new
         filter_manager.include :foo => :bar
         filter_manager.prune([included, excluded]).should eq([included])
       end
 
       it "excludes objects with tags matching exclusions" do
-        included = RSpec::Core::Metadata.new
-        excluded = RSpec::Core::Metadata.new({:foo => :bar})
+        included = filterable_object_with
+        excluded = filterable_object_with({:foo => :bar})
         filter_manager = FilterManager.new
         filter_manager.exclude :foo => :bar
         filter_manager.prune([included, excluded]).should eq([included])
       end
 
       it "prefers exclusion when matches previously set inclusion" do
-        included = RSpec::Core::Metadata.new
-        excluded = RSpec::Core::Metadata.new({:foo => :bar})
+        included = filterable_object_with
+        excluded = filterable_object_with({:foo => :bar})
         filter_manager = FilterManager.new
         filter_manager.include :foo => :bar
         filter_manager.exclude :foo => :bar
@@ -55,8 +115,8 @@ module RSpec::Core
       end
 
       it "prefers inclusion when matches previously set exclusion" do
-        included = RSpec::Core::Metadata.new({:foo => :bar})
-        excluded = RSpec::Core::Metadata.new
+        included = filterable_object_with({:foo => :bar})
+        excluded = filterable_object_with
         filter_manager = FilterManager.new
         filter_manager.exclude :foo => :bar
         filter_manager.include :foo => :bar
@@ -64,20 +124,20 @@ module RSpec::Core
       end
 
       it "prefers previously set inclusion when exclusion matches but has lower priority" do
-        included = RSpec::Core::Metadata.new({:foo => :bar})
-        excluded = RSpec::Core::Metadata.new
+        included = filterable_object_with({:foo => :bar})
+        excluded = filterable_object_with
         filter_manager = FilterManager.new
         filter_manager.include :foo => :bar
-        filter_manager.exclude :low, :foo => :bar
+        filter_manager.exclude_with_low_priority :foo => :bar
         filter_manager.prune([included, excluded]).should eq([included])
       end
 
       it "prefers previously set exclusion when inclusion matches but has lower priority" do
-        included = RSpec::Core::Metadata.new
-        excluded = RSpec::Core::Metadata.new({:foo => :bar})
+        included = filterable_object_with
+        excluded = filterable_object_with({:foo => :bar})
         filter_manager = FilterManager.new
         filter_manager.exclude :foo => :bar
-        filter_manager.include :low, :foo => :bar
+        filter_manager.include_with_low_priority :foo => :bar
         filter_manager.prune([included, excluded]).should eq([included])
       end
     end
@@ -130,12 +190,24 @@ module RSpec::Core
         filter_manager.exclude :if => :custom_filter
       end
 
+      it 'deprecates an :if filter overridden with low priority' do
+        RSpec.should_receive(:warn_deprecation).with(/exclude\(:if.*is deprecated/)
+        filter_manager = FilterManager.new
+        filter_manager.exclude_with_low_priority :if => :custom_filter
+      end
+
       it 'deprecates an overridden :unless filter' do
         RSpec.should_receive(:warn_deprecation).with(/exclude\(:unless.*is deprecated/)
         filter_manager = FilterManager.new
         filter_manager.exclude :unless => :custom_filter
       end
 
+      it 'deprecates an :unless filter overridden with low priority' do
+        RSpec.should_receive(:warn_deprecation).with(/exclude\(:unless.*is deprecated/)
+        filter_manager = FilterManager.new
+        filter_manager.exclude_with_low_priority :unless => :custom_filter
+      end
+
       it 'includes an overriden :if filter' do
         RSpec.stub(:warn_deprecation)
         filter_manager = FilterManager.new
@@ -171,5 +243,14 @@ module RSpec::Core
       filter_manager.include :full_description => "this and that"
       filter_manager.inclusions.should eq(:full_description => "this and that")
     end
+
+    [:locations, :line_numbers, :full_description].each do |filter|
+      it "does nothing on include if already set standalone filter #{filter}" do
+        filter_manager = FilterManager.new
+        filter_manager.include filter => "a_value"
+        filter_manager.include :foo => :bar
+        filter_manager.inclusions.should eq(filter => "a_value")
+      end
+    end
   end
 end