rspec-core 2.5.1 → 2.6.0

data/features/hooks/filtering.feature

@@ -5,187 +5,223 @@ Feature: filters
   or example group, and used to make a hook only apply to examples with the
   given metadata.
 
+  If you set the `treat_symbols_as_metadata_keys_with_true_values` config option
+  to `true`, you can specify metadata using only symbols.
+
   Scenario: filter `before(:each)` hooks using arbitrary metadata
     Given a file named "filter_before_each_hooks_spec.rb" with:
       """
       RSpec.configure do |config|
-        config.before(:each, :foo => :bar) { puts "In hook" }
+        config.before(:each, :foo => :bar) do
+          invoked_hooks << :before_each_foo_bar
+        end
       end
 
-      describe "group 1" do
-        it("example 1") { }
-        it("example 2", :foo => :bar) { }
-      end
+      describe "a filtered before :each hook" do
+        let(:invoked_hooks) { [] }
 
-      describe "group 2", :foo => :bar do
-        it("example 1") { }
-        it("example 2", :foo => :bar) { }
-      end
-      """
-    When I run "rspec filter_before_each_hooks_spec.rb --format documentation"
-    Then the output should contain:
-      """
-      group 1
-        example 1
-      In hook
-        example 2
+        describe "group without matching metadata" do
+          it "does not run the hook" do
+            invoked_hooks.should be_empty
+          end
 
-      group 2
-      In hook
-        example 1
-      In hook
-        example 2
+          it "runs the hook for an example with matching metadata", :foo => :bar do
+            invoked_hooks.should == [:before_each_foo_bar]
+          end
+        end
+
+        describe "group with matching metadata", :foo => :bar do
+          it "runs the hook" do
+            invoked_hooks.should == [:before_each_foo_bar]
+          end
+        end
+      end
       """
+    When I run `rspec filter_before_each_hooks_spec.rb`
+    Then the examples should all pass
 
   Scenario: filter `after(:each)` hooks using arbitrary metadata
     Given a file named "filter_after_each_hooks_spec.rb" with:
       """
       RSpec.configure do |config|
-        config.after(:each, :foo => :bar) { puts "In hook" }
+        config.after(:each, :foo => :bar) do
+          raise "boom!"
+        end
       end
 
-      describe "group 1" do
-        it("example 1") { }
-        it("example 2", :foo => :bar) { }
-      end
+      describe "a filtered after :each hook" do
+        describe "group without matching metadata" do
+          it "does not run the hook" do
+            # should pass
+          end
 
-      describe "group 2", :foo => :bar do
-        it("example 1") { }
-        it("example 2", :foo => :bar) { }
-      end
-      """
-    When I run "rspec filter_after_each_hooks_spec.rb --format documentation"
-    Then the output should contain:
-      """
-      group 1
-        example 1
-      In hook
-        example 2
+          it "runs the hook for an example with matching metadata", :foo => :bar do
+            # should fail
+          end
+        end
 
-      group 2
-      In hook
-        example 1
-      In hook
-        example 2
+        describe "group with matching metadata", :foo => :bar do
+          it "runs the hook" do
+            # should fail
+          end
+        end
+      end
       """
+    When I run `rspec filter_after_each_hooks_spec.rb`
+    Then the output should contain "3 examples, 2 failures"
 
   Scenario: filter around(:each) hooks using arbitrary metadata
     Given a file named "filter_around_each_hooks_spec.rb" with:
       """
       RSpec.configure do |config|
         config.around(:each, :foo => :bar) do |example|
-          puts "Start hook"
+          order << :before_around_each_foo_bar
           example.run
-          puts "End hook"
+          order.should == [:before_around_each_foo_bar, :example]
         end
       end
 
-      describe "group 1" do
-        it("example 1") { }
-        it("example 2", :foo => :bar) { }
-      end
+      describe "a filtered around(:each) hook" do
+        let(:order) { [] }
 
-      describe "group 2", :foo => :bar do
-        it("example 1") { }
-        it("example 2", :foo => :bar) { }
-      end
-      """
-    When I run "rspec filter_around_each_hooks_spec.rb --format documentation"
-    Then the output should contain:
-      """
-      group 1
-        example 1
-      Start hook
-      End hook
-        example 2
+        describe "a group without matching metadata" do
+          it "does not run the hook" do
+            order.should be_empty
+          end
 
-      group 2
-      Start hook
-      End hook
-        example 1
-      Start hook
-      End hook
-        example 2
+          it "runs the hook for an example with matching metadata", :foo => :bar do
+            order.should == [:before_around_each_foo_bar]
+            order << :example
+          end
+        end
+
+        describe "a group with matching metadata", :foo => :bar do
+          it "runs the hook for an example with matching metadata", :foo => :bar do
+            order.should == [:before_around_each_foo_bar]
+            order << :example
+          end
+        end
+      end
       """
+    When I run `rspec filter_around_each_hooks_spec.rb`
+    Then the examples should all pass
 
   Scenario: filter before(:all) hooks using arbitrary metadata
     Given a file named "filter_before_all_hooks_spec.rb" with:
       """
       RSpec.configure do |config|
-        config.before(:all, :foo => :bar) { puts "In hook" }
-      end
-
-      describe "group 1" do
-        it("example 1") { }
-        it("example 2") { }
+        config.before(:all, :foo => :bar) { @hook = :before_all_foo_bar }
       end
 
-      describe "group 2", :foo => :bar do
-        it("example 1") { }
-        it("example 2") { }
-      end
+      describe "a filtered before(:all) hook" do
+        describe "a group without matching metadata" do
+          it "does not run the hook" do
+            @hook.should be_nil
+          end
 
-      describe "group 3" do
-        describe "subgroup 1", :foo => :bar do
-          it("example 1") { }
+          describe "a nested subgroup with matching metadata", :foo => :bar do
+            it "runs the hook" do
+              @hook.should == :before_all_foo_bar
+            end
+          end
         end
-      end
-      """
-    When I run "rspec filter_before_all_hooks_spec.rb --format documentation"
-    Then the output should contain:
-      """
-      group 1
-        example 1
-        example 2
 
-      group 2
-      In hook
-        example 1
-        example 2
+        describe "a group with matching metadata", :foo => :bar do
+          it "runs the hook" do
+            @hook.should == :before_all_foo_bar
+          end
 
-      group 3
-        subgroup 1
-      In hook
-          example 1
+          describe "a nested subgroup" do
+            it "runs the hook" do
+              @hook.should == :before_all_foo_bar
+            end
+          end
+        end
+      end
       """
+    When I run `rspec filter_before_all_hooks_spec.rb`
+    Then the examples should all pass
 
   Scenario: filter after(:all) hooks using arbitrary metadata
     Given a file named "filter_after_all_hooks_spec.rb" with:
       """
+      example_msgs = []
+
       RSpec.configure do |config|
-        config.after(:all, :foo => :bar) { puts "In hook" }
+        config.after(:all, :foo => :bar) do
+          puts "after :all"
+        end
       end
 
-      describe "group 1" do
-        it("example 1") { }
-        it("example 2") { }
-      end
+      describe "a filtered after(:all) hook" do
+        describe "a group without matching metadata" do
+          it "does not run the hook" do
+            puts "unfiltered"
+          end
+        end
 
-      describe "group 2", :foo => :bar do
-        it("example 1") { }
-        it("example 2") { }
-      end
+        describe "a group with matching metadata", :foo => :bar do
+          it "runs the hook" do
+            puts "filtered 1"
+          end
+        end
 
-      describe "group 3" do
-        describe "subgroup 1", :foo => :bar do
-          it("example 1") { }
+        describe "another group without matching metadata" do
+          describe "a nested subgroup with matching metadata", :foo => :bar do
+            it "runs the hook" do
+              puts "filtered 2"
+            end
+          end
         end
       end
       """
-    When I run "rspec filter_after_all_hooks_spec.rb --format documentation"
-    Then the output should contain:
+    When I run `rspec filter_after_all_hooks_spec.rb`
+    Then the examples should all pass
+    And the output should contain:
+      """
+      unfiltered
+      .filtered 1
+      .after :all
+      filtered 2
+      .after :all
       """
-      group 1
-        example 1
-        example 2
 
-      group 2
-        example 1
-        example 2
-      In hook
+  Scenario: Use symbols as metadata
+    Given a file named "less_verbose_metadata_filter.rb" with:
+      """
+      RSpec.configure do |c|
+        c.treat_symbols_as_metadata_keys_with_true_values = true
+        c.before(:each, :before_each) { puts "before each" }
+        c.after(:each,  :after_each) { puts "after each" }
+        c.around(:each, :around_each) do |example|
+          puts "around each (before)"
+          example.run
+          puts "around each (after)"
+        end
+        c.before(:all, :before_all) { puts "before all" }
+        c.after(:all,  :after_all) { puts "after all" }
+      end
 
-      group 3
-        subgroup 1
-          example 1
-      In hook
+      describe "group 1", :before_all, :after_all do
+        it("") { puts "example 1" }
+        it("", :before_each) { puts "example 2" }
+        it("", :after_each) { puts "example 3" }
+        it("", :around_each) { puts "example 4" }
+      end
       """
+    When I run `rspec less_verbose_metadata_filter.rb`
+    Then the examples should all pass
+    And the output should contain:
+      """
+      before all
+      example 1
+      .before each
+      example 2
+      .example 3
+      after each
+      .around each (before)
+      example 4
+      around each (after)
+      .after all
+      """
+

data/features/metadata/current_example.feature

@@ -0,0 +1,17 @@
+Feature: current example
+
+  You can reference the example object, and access its metadata, using
+  the `example` method within an example.
+
+  Scenario: access the example object from within an example
+    Given a file named "spec/example_spec.rb" with:
+      """
+      describe "an example" do
+        it "knows itself as example" do
+          example.description.should eq("knows itself as example")
+        end
+      end
+      """
+    When I run `rspec spec/example_spec.rb`
+    Then the example should pass
+

data/features/metadata/described_class.feature

@@ -12,6 +12,6 @@ Feature: described class
         end
       end
       """
-    When I run "rspec ./spec/example_spec.rb"
-    Then the examples should all pass
+    When I run `rspec spec/example_spec.rb`
+    Then the example should pass
 

data/features/metadata/user_defined.feature

@@ -0,0 +1,111 @@
+Feature: User-defined metadata
+
+  You can attach user-defined metadata to any example group or example.
+  Pass a hash as the last argument (before the block) to `describe`,
+  `context` or `it`.  RSpec supports many configuration options that apply
+  only to certain examples or groups based on the metadata.
+
+  Metadata defined on an example group is available (and can be overridden)
+  by any sub-group or from any example in that group or a sub-group.
+
+  In addition, there is a configuration option (which will be the default
+  behavior in RSpec 3) that allows you to specify metadata using just
+  symbols:
+
+    RSpec.configure do |c|
+      c.treat_symbols_as_metadata_keys_with_true_values = true
+    end
+
+  Each symbol passed as an argument to `describe`, `context` or `it` will
+  be a key in the metadata hash, with a corresponding value of `true`.
+
+  Scenario: define group metadata using a hash
+    Given a file named "define_group_metadata_with_hash_spec.rb" with:
+      """
+      describe "a group with user-defined metadata", :foo => 17 do
+        it 'has access to the metadata in the example' do
+          example.metadata[:foo].should == 17
+        end
+
+        it 'does not have access to metadata defined on sub-groups' do
+          example.metadata.should_not include(:bar)
+        end
+
+        describe 'a sub-group with user-defined metadata', :bar => 12 do
+          it 'has access to the sub-group metadata' do
+            example.metadata[:foo].should == 17
+          end
+
+          it 'also has access to metadata defined on parent groups' do
+            example.metadata[:bar].should == 12
+          end
+        end
+      end
+      """
+    When I run `rspec define_group_metadata_with_hash_spec.rb`
+    Then the examples should all pass
+
+  Scenario: define example metadata using a hash
+    Given a file named "define_example_metadata_with_hash_spec.rb" with:
+      """
+      describe "a group with no user-defined metadata" do
+        it 'has an example with metadata', :foo => 17 do
+          example.metadata[:foo].should == 17
+          example.metadata.should_not include(:bar)
+        end
+
+        it 'has another example with metadata', :bar => 12, :bazz => 33 do
+          example.metadata[:bar].should == 12
+          example.metadata[:bazz].should == 33
+          example.metadata.should_not include(:foo)
+        end
+      end
+      """
+    When I run `rspec define_example_metadata_with_hash_spec.rb`
+    Then the examples should all pass
+
+  Scenario: override user-defined metadata
+    Given a file named "override_metadata_spec.rb" with:
+      """
+      describe "a group with user-defined metadata", :foo => 'bar' do
+        it 'can be overridden by an example', :foo => 'bazz' do
+          example.metadata[:foo].should == 'bazz'
+        end
+
+        describe "a sub-group with an override", :foo => 'goo' do
+          it 'can be overridden by a sub-group' do
+            example.metadata[:foo].should == 'goo'
+          end
+        end
+      end
+      """
+    When I run `rspec override_metadata_spec.rb`
+    Then the examples should all pass
+
+  Scenario: less verbose metadata
+    Given a file named "less_verbose_metadata_spec.rb" with:
+      """
+      RSpec.configure do |c|
+        c.treat_symbols_as_metadata_keys_with_true_values = true
+      end
+
+      describe "a group with simple metadata", :fast, :simple, :bug => 73 do
+        it 'has `:fast => true` metadata' do
+          example.metadata[:fast].should == true
+        end
+
+        it 'has `:simple => true` metadata' do
+          example.metadata[:simple].should == true
+        end
+
+        it 'can still use a hash for metadata' do
+          example.metadata[:bug].should == 73
+        end
+
+        it 'can define simple metadata on an example', :special do
+          example.metadata[:special].should == true
+        end
+      end
+      """
+    When I run `rspec less_verbose_metadata_spec.rb`
+    Then the examples should all pass

data/features/mock_framework_integration/use_any_framework.feature

@@ -100,7 +100,7 @@ Feature: mock with an alternative framework
         end
       end
       """
-    When I run "rspec example_spec.rb --format doc"
+    When I run `rspec example_spec.rb --format doc`
     Then the exit status should be 1
     And the output should contain "2 examples, 1 failure" 
     And the output should contain "fails when message is received (FAILED - 1)" 

data/features/mock_framework_integration/use_flexmock.feature

@@ -1,23 +1,96 @@
 Feature: mock with flexmock
 
-  As an RSpec user who likes to mock
-  I want to be able to use flexmock
+  Configure RSpec to use flexmock as shown in the scenarios below.
 
-  Scenario: Mock with flexmock
-    Given a file named "flexmock_example_spec.rb" with:
+  Scenario: passing message expectation
+    Given a file named "example_spec.rb" with:
       """
       RSpec.configure do |config|
         config.mock_framework = :flexmock
       end
 
-      describe "plugging in flexmock" do
-        it "allows flexmock to be used" do
-          target = Object.new
-          flexmock(target).should_receive(:foo).once
-          target.foo
+      describe "mocking with RSpec" do
+        it "passes when it should" do
+          receiver = flexmock('receiver')
+          receiver.should_receive(:message).once
+          receiver.message
         end
       end
       """
-    When I run "rspec ./flexmock_example_spec.rb"
+    When I run `rspec example_spec.rb`
     Then the examples should all pass 
+
+  Scenario: failing message expecation
+    Given a file named "example_spec.rb" with:
+      """
+      RSpec.configure do |config|
+        config.mock_framework = :flexmock
+      end
+
+      describe "mocking with RSpec" do
+        it "fails when it should" do
+          receiver = flexmock('receiver')
+          receiver.should_receive(:message).once
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain "1 example, 1 failure"
+
+  Scenario: failing message expectation in pending block (remains pending)
+    Given a file named "example_spec.rb" with:
+      """
+      RSpec.configure do |config|
+        config.mock_framework = :flexmock
+      end
+
+      describe "failed message expectation in a pending block" do
+        it "is listed as pending" do
+          pending do
+            receiver = flexmock('receiver')
+            receiver.should_receive(:message).once
+          end
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain "1 example, 0 failures, 1 pending"
     And the exit status should be 0
+
+  Scenario: passing message expectation in pending block (fails)
+    Given a file named "example_spec.rb" with:
+      """
+      RSpec.configure do |config|
+        config.mock_framework = :flexmock
+      end
+
+      describe "passing message expectation in a pending block" do
+        it "fails with FIXED" do
+          pending do
+            receiver = flexmock('receiver')
+            receiver.should_receive(:message).once
+            receiver.message
+          end
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain "FIXED"
+    Then the output should contain "1 example, 1 failure"
+    And the exit status should be 1
+
+  Scenario: accessing RSpec.configuration.mock_framework.framework_name 
+    Given a file named "example_spec.rb" with:
+      """
+      RSpec.configure do |config|
+        config.mock_framework = :flexmock
+      end
+
+      describe "RSpec.configuration.mock_framework.framework_name" do
+        it "returns :flexmock" do
+          RSpec.configuration.mock_framework.framework_name.should eq(:flexmock)
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass