rspec-core 3.0.0.beta2 → 3.0.0.rc1

data/features/hooks/around_hooks.feature

@@ -1,344 +0,0 @@
-Feature: around hooks
-
-  Around hooks receive the example as a block argument, extended to behave like
-  a proc.  This lets you define code that should be executed before and after
-  the example. Of course, you can do the same thing with before and after hooks,
-  and it's often cleaner to do so.
-
-  Where around hooks shine is when you want to run an example in a block. For
-  example, if your database library offers a transaction method that receives
-  a block, you can use an around hook as described in the first scenario:
-
-  WARNING: around hooks do not share state with the example the way before and
-  after hooks do. This means that you can not share instance variables between
-  around hooks and examples.
-
-  Also, mock frameworks are set up and torn down within the context of running
-  the example, so you can not interact with them directly in around hooks.
-
-  Scenario: use the example as a proc within the block passed to around()
-    Given a file named "example_spec.rb" with:
-      """ruby
-      class Database
-        def self.transaction
-          puts "open transaction"
-          yield
-          puts "close transaction"
-        end
-      end
-
-      describe "around filter" do
-        around(:each) do |example|
-          Database.transaction(&example)
-        end
-
-        it "gets run in order" do
-          puts "run the example"
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain:
-      """
-      open transaction
-      run the example
-      close transaction
-      """
-
-  Scenario: invoke the example using run()
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "around hook" do
-        around(:each) do |example|
-          puts "around each before"
-          example.run
-          puts "around each after"
-        end
-
-        it "gets run in order" do
-          puts "in the example"
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain:
-      """
-      around each before
-      in the example
-      around each after
-      """
-
-  Scenario: access the example metadata
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "something" do
-        around(:each) do |example|
-          puts example.metadata[:foo]
-          example.run
-        end
-
-        it "does something", :foo => "this should show up in the output" do
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain "this should show up in the output"
-
-  Scenario: define a global around hook
-    Given a file named "example_spec.rb" with:
-      """ruby
-      RSpec.configure do |c|
-        c.around(:each) do |example|
-          puts "around each before"
-          example.run
-          puts "around each after"
-        end
-      end
-
-      describe "around filter" do
-        it "gets run in order" do
-          puts "in the example"
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain:
-      """
-      around each before
-      in the example
-      around each after
-      """
-
-  Scenario: before/after(:each) hooks are wrapped by the around hook
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "around filter" do
-        around(:each) do |example|
-          puts "around each before"
-          example.run
-          puts "around each after"
-        end
-
-        before(:each) do
-          puts "before each"
-        end
-
-        after(:each) do
-          puts "after each"
-        end
-
-        it "gets run in order" do
-          puts "in the example"
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain:
-      """
-      around each before
-      before each
-      in the example
-      after each
-      around each after
-      """
-
-  Scenario: before/after(:all) hooks are NOT wrapped by the around hook
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "around filter" do
-        around(:each) do |example|
-          puts "around each before"
-          example.run
-          puts "around each after"
-        end
-
-        before(:all) do
-          puts "before all"
-        end
-
-        after(:all) do
-          puts "after all"
-        end
-
-        it "gets run in order" do
-          puts "in the example"
-        end
-      end
-      """
-    When I run `rspec --format progress example_spec.rb`
-    Then the output should contain:
-      """
-      before all
-      around each before
-      in the example
-      around each after
-      .after all
-      """
-
-  Scenario: examples run by an around block are run in the configured context
-    Given a file named "example_spec.rb" with:
-      """ruby
-      module IncludedInConfigureBlock
-        def included_in_configure_block; true; end
-      end
-
-      RSpec.configure do |c|
-        c.include IncludedInConfigureBlock
-      end
-
-      describe "around filter" do
-        around(:each) do |example|
-          example.run
-        end
-
-        it "runs the example in the correct context" do
-          expect(included_in_configure_block).to be_truthy
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain "1 example, 0 failure"
-
-  Scenario: implicitly pending examples are detected as Not yet implemented
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "implicit pending example" do
-        around(:each) do |example|
-          example.run
-        end
-
-        it "should be detected as Not yet implemented"
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain "1 example, 0 failures, 1 pending"
-    And the output should contain:
-      """
-      Pending:
-        implicit pending example should be detected as Not yet implemented
-          # Not yet implemented
-      """
-
-
-  Scenario: explicitly pending examples are detected as pending
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "explicit pending example" do
-        around(:each) do |example|
-          example.run
-        end
-
-        it "should be detected as pending" do
-          pending
-          fail
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain "1 example, 0 failures, 1 pending"
-    And the output should contain:
-      """
-        explicit pending example should be detected as pending
-          # No reason given
-      """
-
-  Scenario: multiple around hooks in the same scope
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "if there are multiple around hooks in the same scope" do
-        around(:each) do |example|
-          puts "first around hook before"
-          example.run
-          puts "first around hook after"
-        end
-
-        around(:each) do |example|
-          puts "second around hook before"
-          example.run
-          puts "second around hook after"
-        end
-
-        it "they should all be run" do
-          puts "in the example"
-          expect(1).to eq(1)
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain "1 example, 0 failure"
-    And the output should contain:
-      """
-      first around hook before
-      second around hook before
-      in the example
-      second around hook after
-      first around hook after
-      """
-
-  Scenario: around hooks in multiple scopes
-    Given a file named "example_spec.rb" with:
-    """ruby
-    describe "if there are around hooks in an outer scope" do
-      around(:each) do |example|
-        puts "first outermost around hook before"
-        example.run
-        puts "first outermost around hook after"
-      end
-
-      around(:each) do |example|
-        puts "second outermost around hook before"
-        example.run
-        puts "second outermost around hook after"
-      end
-
-      describe "outer scope" do
-        around(:each) do |example|
-          puts "first outer around hook before"
-          example.run
-          puts "first outer around hook after"
-        end
-
-        around(:each) do |example|
-          puts "second outer around hook before"
-          example.run
-          puts "second outer around hook after"
-        end
-
-        describe "inner scope" do
-          around(:each) do |example|
-            puts "first inner around hook before"
-            example.run
-            puts "first inner around hook after"
-          end
-
-          around(:each) do |example|
-            puts "second inner around hook before"
-            example.run
-            puts "second inner around hook after"
-          end
-
-          it "they should all be run" do
-            puts "in the example"
-          end
-        end
-      end
-    end
-    """
-    When I run `rspec example_spec.rb`
-    Then the output should contain "1 example, 0 failure"
-    And the output should contain:
-    """
-    first outermost around hook before
-    second outermost around hook before
-    first outer around hook before
-    second outer around hook before
-    first inner around hook before
-    second inner around hook before
-    in the example
-    second inner around hook after
-    first inner around hook after
-    second outer around hook after
-    first outer around hook after
-    second outermost around hook after
-    first outermost around hook after
-    """

data/features/hooks/before_and_after_hooks.feature

@@ -1,427 +0,0 @@
-Feature: before and after hooks
-
-  Use `before` and `after` hooks to execute arbitrary code before and/or
-  after the body of an example is run:
-
-      before(:each) # run before each example
-      before(:all)  # run one time only, before all of the examples in a group
-
-      after(:each) # run after each example
-      after(:all)  # run one time only, after all of the examples in a group
-
-  Before and after blocks are called in the following order:
-
-      before suite
-      before all
-      before each
-      after  each
-      after  all
-      after  suite
-
-  `before` and `after` hooks can be defined directly in the example groups they
-  should run in, or in a global RSpec.configure block.
-
-  Setting instance variables are not supported in `before(:suite)`.
-
-  Mocks are only supported in `before(:each)`.
-
-  Scenario: define before(:each) block
-    Given a file named "before_each_spec.rb" with:
-      """ruby
-      require "rspec/expectations"
-
-      class Thing
-        def widgets
-          @widgets ||= []
-        end
-      end
-
-      describe Thing do
-        before(:each) do
-          @thing = Thing.new
-        end
-
-        describe "initialized in before(:each)" do
-          it "has 0 widgets" do
-            expect(@thing.widgets.count).to eq(0)
-          end
-
-          it "can accept new widgets" do
-            @thing.widgets << Object.new
-          end
-
-          it "does not share state across examples" do
-            expect(@thing.widgets.count).to eq(0)
-          end
-        end
-      end
-      """
-    When I run `rspec before_each_spec.rb`
-    Then the examples should all pass
-
-  Scenario: define before(:all) block in example group
-    Given a file named "before_all_spec.rb" with:
-      """ruby
-      require "rspec/expectations"
-
-      class Thing
-        def widgets
-          @widgets ||= []
-        end
-      end
-
-      describe Thing do
-        before(:all) do
-          @thing = Thing.new
-        end
-
-        describe "initialized in before(:all)" do
-          it "has 0 widgets" do
-            expect(@thing.widgets.count).to eq(0)
-          end
-
-          it "can accept new widgets" do
-            @thing.widgets << Object.new
-          end
-
-          it "shares state across examples" do
-            expect(@thing.widgets.count).to eq(1)
-          end
-        end
-      end
-      """
-    When I run `rspec before_all_spec.rb`
-    Then the examples should all pass
-
-    When I run `rspec before_all_spec.rb:15`
-    Then the examples should all pass
-
-  Scenario: failure in before(:all) block
-    Given a file named "before_all_spec.rb" with:
-      """ruby
-      describe "an error in before(:all)" do
-        before(:all) do
-          raise "oops"
-        end
-
-        it "fails this example" do
-        end
-
-        it "fails this example, too" do
-        end
-
-        after(:all) do
-          puts "after all ran"
-        end
-
-        describe "nested group" do
-          it "fails this third example" do
-          end
-
-          it "fails this fourth example" do
-          end
-
-          describe "yet another level deep" do
-            it "fails this last example" do
-            end
-          end
-        end
-      end
-      """
-    When I run `rspec before_all_spec.rb --format documentation`
-    Then the output should contain "5 examples, 5 failures"
-    And the output should contain:
-      """
-      an error in before(:all)
-        fails this example (FAILED - 1)
-        fails this example, too (FAILED - 2)
-        nested group
-          fails this third example (FAILED - 3)
-          fails this fourth example (FAILED - 4)
-          yet another level deep
-            fails this last example (FAILED - 5)
-      after all ran
-      """
-
-    When I run `rspec before_all_spec.rb:9 --format documentation`
-    Then the output should contain "1 example, 1 failure"
-    And the output should contain:
-      """
-      an error in before(:all)
-        fails this example, too (FAILED - 1)
-      """
-
-  Scenario: failure in after(:all) block
-    Given a file named "after_all_spec.rb" with:
-      """ruby
-      describe "an error in after(:all)" do
-        after(:all) do
-          raise StandardError.new("Boom!")
-        end
-
-        it "passes this example" do
-        end
-
-        it "passes this example, too" do
-        end
-      end
-      """
-    When I run `rspec after_all_spec.rb`
-    Then the examples should all pass
-    And the output should contain:
-      """
-      An error occurred in an after(:all) hook.
-        StandardError: Boom!
-      """
-
-  Scenario: define before and after blocks in configuration
-    Given a file named "befores_in_configuration_spec.rb" with:
-      """ruby
-      require "rspec/expectations"
-
-      RSpec.configure do |config|
-        config.before(:each) do
-          @before_each = "before each"
-        end
-        config.before(:all) do
-          @before_all = "before all"
-        end
-      end
-
-      describe "stuff in before blocks" do
-        describe "with :all" do
-          it "should be available in the example" do
-            expect(@before_all).to eq("before all")
-          end
-        end
-        describe "with :each" do
-          it "should be available in the example" do
-            expect(@before_each).to eq("before each")
-          end
-        end
-      end
-      """
-    When I run `rspec befores_in_configuration_spec.rb`
-    Then the examples should all pass
-
-  Scenario: before/after blocks are run in order
-    Given a file named "ensure_block_order_spec.rb" with:
-      """ruby
-      require "rspec/expectations"
-
-      describe "before and after callbacks" do
-        before(:all) do
-          puts "before all"
-        end
-
-        before(:each) do
-          puts "before each"
-        end
-
-        after(:each) do
-          puts "after each"
-        end
-
-        after(:all) do
-          puts "after all"
-        end
-
-        it "gets run in order" do
-
-        end
-      end
-      """
-    When I run `rspec --format progress ensure_block_order_spec.rb`
-    Then the output should contain:
-      """
-      before all
-      before each
-      after each
-      .after all
-      """
-
-  Scenario: before/after blocks defined in config are run in order
-    Given a file named "configuration_spec.rb" with:
-      """ruby
-      require "rspec/expectations"
-
-      RSpec.configure do |config|
-        config.before(:suite) do
-          puts "before suite"
-        end
-
-        config.before(:all) do
-          puts "before all"
-        end
-
-        config.before(:each) do
-          puts "before each"
-        end
-
-        config.after(:each) do
-          puts "after each"
-        end
-
-        config.after(:all) do
-          puts "after all"
-        end
-
-        config.after(:suite) do
-          puts "after suite"
-        end
-      end
-
-      describe "ignore" do
-        example "ignore" do
-        end
-      end
-      """
-    When I run `rspec --format progress configuration_spec.rb`
-    Then the output should contain:
-      """
-      before suite
-      before all
-      before each
-      after each
-      .after all
-      after suite
-      """
-
-  Scenario: before/after all blocks are run once
-    Given a file named "before_and_after_all_spec.rb" with:
-      """ruby
-      describe "before and after callbacks" do
-        before(:all) do
-          puts "outer before all"
-        end
-
-        example "in outer group" do
-        end
-
-        after(:all) do
-          puts "outer after all"
-        end
-
-        describe "nested group" do
-          before(:all) do
-            puts "inner before all"
-          end
-
-          example "in nested group" do
-          end
-
-          after(:all) do
-            puts "inner after all"
-          end
-        end
-
-      end
-      """
-    When I run `rspec --format progress before_and_after_all_spec.rb`
-    Then the examples should all pass
-    And the output should contain:
-      """
-      outer before all
-      .inner before all
-      .inner after all
-      outer after all
-      """
-
-    When I run `rspec --format progress before_and_after_all_spec.rb:14`
-    Then the examples should all pass
-    And the output should contain:
-      """
-      outer before all
-      inner before all
-      .inner after all
-      outer after all
-      """
-
-    When I run `rspec --format progress before_and_after_all_spec.rb:6`
-    Then the examples should all pass
-    And the output should contain:
-      """
-      outer before all
-      .outer after all
-      """
-
-  Scenario: nested examples have access to state set in outer before(:all)
-    Given a file named "before_all_spec.rb" with:
-      """ruby
-      describe "something" do
-        before :all do
-          @value = 123
-        end
-
-        describe "nested" do
-          it "access state set in before(:all)" do
-            expect(@value).to eq(123)
-          end
-
-          describe "nested more deeply" do
-            it "access state set in before(:all)" do
-              expect(@value).to eq(123)
-            end
-          end
-        end
-
-        describe "nested in parallel" do
-          it "access state set in before(:all)" do
-            expect(@value).to eq(123)
-          end
-        end
-      end
-      """
-    When I run `rspec before_all_spec.rb`
-    Then the examples should all pass
-
-  Scenario: before/after all blocks have access to state
-    Given a file named "before_and_after_all_spec.rb" with:
-      """ruby
-      describe "before and after callbacks" do
-        before(:all) do
-          @outer_state = "set in outer before all"
-        end
-
-        example "in outer group" do
-          expect(@outer_state).to eq("set in outer before all")
-        end
-
-        describe "nested group" do
-          before(:all) do
-            @inner_state = "set in inner before all"
-          end
-
-          example "in nested group" do
-            expect(@outer_state).to eq("set in outer before all")
-            expect(@inner_state).to eq("set in inner before all")
-          end
-
-          after(:all) do
-            expect(@inner_state).to eq("set in inner before all")
-          end
-        end
-
-        after(:all) do
-          expect(@outer_state).to eq("set in outer before all")
-        end
-      end
-      """
-    When I run `rspec before_and_after_all_spec.rb`
-    Then the examples should all pass
-
-  Scenario: exception in before(:each) is captured and reported as failure
-    Given a file named "error_in_before_each_spec.rb" with:
-      """ruby
-      describe "error in before(:each)" do
-        before(:each) do
-          raise "this error"
-        end
-
-        it "is reported as failure" do
-        end
-      end
-      """
-    When I run `rspec error_in_before_each_spec.rb`
-    Then the output should contain "1 example, 1 failure"
-    And the output should contain "this error"