rspec-core 3.0.0.beta2 → 3.0.0.rc1

data/features/hooks/filtering.feature

@@ -1,232 +0,0 @@
-Feature: filters
-
-  `before`, `after`, and `around` hooks defined in the block passed to
-  `RSpec.configure` can be constrained to specific examples and/or groups using
-  metadata as a filter.
-
-      RSpec.configure do |c|
-        c.before(:each, :type => :model) do
-        end
-      end
-
-      describe "something", :type => :model do
-      end
-
-  You can also specify metadata using only symbols.
-
-  Scenario: filter `before(:each)` hooks using arbitrary metadata
-    Given a file named "filter_before_each_hooks_spec.rb" with:
-      """ruby
-      RSpec.configure do |config|
-        config.before(:each, :foo => :bar) do
-          invoked_hooks << :before_each_foo_bar
-        end
-      end
-
-      describe "a filtered before :each hook" do
-        let(:invoked_hooks) { [] }
-
-        describe "group without matching metadata" do
-          it "does not run the hook" do
-            expect(invoked_hooks).to be_empty
-          end
-
-          it "runs the hook for an example with matching metadata", :foo => :bar do
-            expect(invoked_hooks).to eq([:before_each_foo_bar])
-          end
-        end
-
-        describe "group with matching metadata", :foo => :bar do
-          it "runs the hook" do
-            expect(invoked_hooks).to eq([: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:
-      """ruby
-      RSpec.configure do |config|
-        config.after(:each, :foo => :bar) do
-          raise "boom!"
-        end
-      end
-
-      describe "a filtered after :each hook" do
-        describe "group without matching metadata" do
-          it "does not run the hook" do
-            # should pass
-          end
-
-          it "runs the hook for an example with matching metadata", :foo => :bar do
-            # should fail
-          end
-        end
-
-        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:
-      """ruby
-      RSpec.configure do |config|
-        config.around(:each, :foo => :bar) do |example|
-          order << :before_around_each_foo_bar
-          example.run
-          expect(order).to eq([:before_around_each_foo_bar, :example])
-        end
-      end
-
-      describe "a filtered around(:each) hook" do
-        let(:order) { [] }
-
-        describe "a group without matching metadata" do
-          it "does not run the hook" do
-            expect(order).to be_empty
-          end
-
-          it "runs the hook for an example with matching metadata", :foo => :bar do
-            expect(order).to eq([: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
-            expect(order).to eq([: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:
-      """ruby
-      RSpec.configure do |config|
-        config.before(:all, :foo => :bar) { @hook = :before_all_foo_bar }
-      end
-
-      describe "a filtered before(:all) hook" do
-        describe "a group without matching metadata" do
-          it "does not run the hook" do
-            expect(@hook).to be_nil
-          end
-
-          describe "a nested subgroup with matching metadata", :foo => :bar do
-            it "runs the hook" do
-              expect(@hook).to eq(:before_all_foo_bar)
-            end
-          end
-        end
-
-        describe "a group with matching metadata", :foo => :bar do
-          it "runs the hook" do
-            expect(@hook).to eq(:before_all_foo_bar)
-          end
-
-          describe "a nested subgroup" do
-            it "runs the hook" do
-              expect(@hook).to eq(: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:
-      """ruby
-      example_msgs = []
-
-      RSpec.configure do |config|
-        config.after(:all, :foo => :bar) do
-          puts "after :all"
-        end
-      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 "a group with matching metadata", :foo => :bar do
-          it "runs the hook" do
-            puts "filtered 1"
-          end
-        end
-
-        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 --format progress 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
-      """
-
-  Scenario: Use symbols as metadata
-    Given a file named "less_verbose_metadata_filter.rb" with:
-      """ruby
-      RSpec.configure do |c|
-        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
-
-      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 --format progress 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

@@ -1,56 +0,0 @@
-Feature: current example
-
-  You can reference the example object, and access its metadata, using
-  a block argument to it, before and after hooks, let, and subject.
-
-  Scenario: access the example object from within an example
-    Given a file named "spec/example_spec.rb" with:
-      """ruby
-      describe "example as block arg to it, before, and after" do
-        before do |example|
-          expect(example.description).to eq("is the example object")
-        end
-
-        after do |example|
-          expect(example.description).to eq("is the example object")
-        end
-
-        it "is the example object" do |example|
-          expect(example.description).to eq("is the example object")
-        end
-      end
-
-      describe "example as block arg to let" do
-        let(:the_description) do |example|
-          example.description
-        end
-
-        it "is the example object" do |example|
-          expect(the_description).to eq("is the example object")
-        end
-      end
-
-      describe "example as block arg to subject" do
-        subject do |example|
-          example.description
-        end
-
-        it "is the example object" do |example|
-          expect(subject).to eq("is the example object")
-        end
-      end
-
-      describe "example as block arg to subject with a name" do
-        subject(:the_subject) do |example|
-          example.description
-        end
-
-        it "is the example object" do |example|
-          expect(the_subject).to eq("is the example object")
-          expect(subject).to eq("is the example object")
-        end
-      end
-      """
-    When I run `rspec spec/example_spec.rb`
-    Then the example should pass
-

data/features/metadata/described_class.feature

@@ -1,17 +0,0 @@
-Feature: described class
-
-  If the first argument to the outermost example group is a class, the class is
-  exposed to each example via the described_class() method.
-
-  Scenario: access the described class from the example
-    Given a file named "spec/example_spec.rb" with:
-      """ruby
-      describe Fixnum do
-        it "is available as described_class" do
-          expect(described_class).to eq(Fixnum)
-        end
-      end
-      """
-    When I run `rspec spec/example_spec.rb`
-    Then the example should pass
-

data/features/metadata/user_defined.feature

@@ -1,100 +0,0 @@
-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, you can specify metdata using just symbols.
-  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:
-      """ruby
-      describe "a group with user-defined metadata", :foo => 17 do
-        it 'has access to the metadata in the example' do |example|
-          expect(example.metadata[:foo]).to eq(17)
-        end
-
-        it 'does not have access to metadata defined on sub-groups' do |example|
-          expect(example.metadata).not_to include(:bar)
-        end
-
-        describe 'a sub-group with user-defined metadata', :bar => 12 do
-          it 'has access to the sub-group metadata' do |example|
-            expect(example.metadata[:foo]).to eq(17)
-          end
-
-          it 'also has access to metadata defined on parent groups' do |example|
-            expect(example.metadata[:bar]).to eq(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:
-      """ruby
-      describe "a group with no user-defined metadata" do
-        it 'has an example with metadata', :foo => 17 do |example|
-          expect(example.metadata[:foo]).to eq(17)
-          expect(example.metadata).not_to include(:bar)
-        end
-
-        it 'has another example with metadata', :bar => 12, :bazz => 33 do |example|
-          expect(example.metadata[:bar]).to eq(12)
-          expect(example.metadata[:bazz]).to eq(33)
-          expect(example.metadata).not_to 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:
-      """ruby
-      describe "a group with user-defined metadata", :foo => 'bar' do
-        it 'can be overridden by an example', :foo => 'bazz' do |example|
-          expect(example.metadata[:foo]).to eq('bazz')
-        end
-
-        describe "a sub-group with an override", :foo => 'goo' do
-          it 'can be overridden by a sub-group' do |example|
-            expect(example.metadata[:foo]).to eq('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:
-      """ruby
-      describe "a group with simple metadata", :fast, :simple, :bug => 73 do
-        it 'has `:fast => true` metadata' do |example|
-          expect(example.metadata[:fast]).to eq(true)
-        end
-
-        it 'has `:simple => true` metadata' do |example|
-          expect(example.metadata[:simple]).to eq(true)
-        end
-
-        it 'can still use a hash for metadata' do |example|
-          expect(example.metadata[:bug]).to eq(73)
-        end
-
-        it 'can define simple metadata on an example', :special do |example|
-          expect(example.metadata[:special]).to eq(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

@@ -1,106 +0,0 @@
-Feature: mock with an alternative framework
-
-  In addition to rspec, mocha, flexmock, and RR, you can choose an alternate
-  framework as the mocking framework. You (or the framework authors) just needs
-  to provide an adapter that hooks RSpec's events into those of the framework.
-
-  A mock framework adapter must expose three methods:
-
-  * `setup_mocks_for_rspec`
-    * called before each example is run
-  * `verify_mocks_for_rspec`
-    * called after each example is run
-    * this is where message expectation failures should result in an error with
-      the appropriate failure message
-  * `teardown_mocks_for_rspec`
-    * called after `verify_mocks_for_rspec`
-    * use this to clean up resources, restore objects to earlier state, etc
-    * guaranteed to run even if there are failures
-
-  Scenario: Mock with alternate framework
-    Given a file named "expector.rb" with:
-      """ruby
-      class Expector
-        class << self
-          def expectors
-            @expectors ||= []
-          end
-
-          def clear_expectors
-            expectors.clear
-          end
-
-          def verify_expectors
-            expectors.each {|d| d.verify}
-          end
-        end
-
-        def initialize
-          self.class.expectors << self
-        end
-
-        def expectations
-          @expectations ||= []
-        end
-
-        def expect(message)
-          expectations << message.to_s
-        end
-
-        def verify
-          unless expectations.empty?
-            raise expectations.map {|e|
-              "expected #{e}, but it was never received"
-            }.join("\n")
-          end
-        end
-
-      private
-
-        def method_missing(name, *args, &block)
-          expectations.delete(name.to_s)
-        end
-
-      public
-
-        module RSpecAdapter
-          def setup_mocks_for_rspec
-            # no setup necessary
-          end
-
-          def verify_mocks_for_rspec
-            Expector.verify_expectors.each {|d| d.verify}
-          end
-
-          def teardown_mocks_for_rspec
-            Expector.clear_expectors
-          end
-        end
-      end
-      """
-
-    Given a file named "example_spec.rb" with:
-      """ruby
-      require File.expand_path("../expector", __FILE__)
-
-      RSpec.configure do |config|
-        config.mock_framework = Expector::RSpecAdapter
-      end
-
-      describe Expector do
-        it "passes when message is received" do
-          expector = Expector.new
-          expector.expect(:foo)
-          expector.foo
-        end
-
-        it "fails when message is received" do
-          expector = Expector.new
-          expector.expect(:foo)
-        end
-      end
-      """
-    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)"