Module: RSpec::Core::Hooks

Included in:
Configuration, ExampleGroup, World
Defined in:
lib/rspec/core/hooks.rb

Overview

Provides before, after and around hooks as a means of supporting common setup and teardown. This module is extended onto ExampleGroup, making the methods available from any describe or context block and included in Configuration, making them available off of the configuration object to define global setup or teardown logic.

Constant Summary

Instance Method Summary (collapse)

Instance Method Details

- (void) after(&block) - (void) after(scope, &block) - (void) after(scope, conditions, &block) - (void) after(conditions, &block) Also known as: prepend_after

Note:

The :example and :context scopes are also available as :each and :all, respectively. Use whichever you prefer.

Declare a block of code to be run after each example (using :example) or once after all examples n the context (using :context). See #before for more information about ordering.

Exceptions

after hooks are guaranteed to run even when there are exceptions in before hooks or examples. When an exception is raised in an after block, the exception is captured for later reporting, and subsequent after blocks are run.

Order

after hooks are stored in three scopes, which are run in order: :example, :context, and :suite. They can also be declared in several different places: RSpec.configure, a parent group, the current group. They are run in the following order:

after(:example) # declared in the current group
after(:example) # declared in a parent group
after(:example) # declared in RSpec.configure
after(:context) # declared in the current group
after(:context) # declared in a parent group
after(:context) # declared in RSpec.configure
after(:suite)   # declared in RSpec.configure

This is the reverse of the order in which before hooks are run. Similarly, if more than one after is declared within any one scope, they are run in reverse order of that in which they are declared.

Overloads:

  • - (void) after(scope, &block)

    Parameters:

    • scope (Symbol)

      :example, :context, or :suite (defaults to :example)

  • - (void) after(scope, conditions, &block)

    Parameters:

    • scope (Symbol)

      :example, :context, or :suite (defaults to :example)

    • conditions (Hash)

      constrains this hook to examples matching these conditions e.g. after(:example, :ui => true) { ... } will only run with examples or groups declared with :ui => true.

  • - (void) after(conditions, &block)

    Parameters:

    • conditions (Hash)

      constrains this hook to examples matching these conditions e.g. after(:example, :ui => true) { ... } will only run with examples or groups declared with :ui => true.

See Also:



253
254
255
# File 'lib/rspec/core/hooks.rb', line 253

def after(*args, &block)
  hooks.register :prepend, :after, *args, &block
end

- (void) append_after(*args, &block)

Adds block to the back of the list of after blocks in the same scope (:example, :context, or :suite).

See #after for scoping semantics.



263
264
265
# File 'lib/rspec/core/hooks.rb', line 263

def append_after(*args, &block)
  hooks.register :append, :after, *args, &block
end

- (void) around(&block) - (void) around(scope, &block) - (void) around(scope, conditions, &block) - (void) around(conditions, &block)

Note:

the syntax of around is similar to that of before and after but the semantics are quite different. before and after hooks are run in the context of of the examples with which they are associated, whereas around hooks are actually responsible for running the examples. Consequently, around hooks do not have direct access to resources that are made available within the examples and their associated before and after hooks.

Note:

:example/:each is the only supported scope.

Declare a block of code, parts of which will be run before and parts after the example. It is your responsibility to run the example:

around(:example) do |ex|
  # do some stuff before
  ex.run
  # do some stuff after
end

The yielded example aliases run with call, which lets you treat it like a Proc. This is especially handy when working with libaries that manage their own setup and teardown using a block or proc syntax, e.g.

around(:example) {|ex| Database.transaction(&ex)}
around(:example) {|ex| FakeFS(&ex)}

Overloads:

  • - (void) around(scope, &block)

    Parameters:

    • scope (Symbol)

      :example (defaults to :example) present for syntax parity with before and after, but :example/:each is the only supported value.

  • - (void) around(scope, conditions, &block)

    Parameters:

    • scope (Symbol)

      :example (defaults to :example) present for syntax parity with before and after, but :example/:each is the only supported value.

    • conditions (Hash)

      constrains this hook to examples matching these conditions e.g. around(:example, :ui => true) { ... } will only run with examples or groups declared with :ui => true.

  • - (void) around(conditions, &block)

    Parameters:

    • conditions (Hash)

      constrains this hook to examples matching these conditions e.g. around(:example, :ui => true) { ... } will only run with examples or groups declared with :ui => true.

Yields:



316
317
318
# File 'lib/rspec/core/hooks.rb', line 316

def around(*args, &block)
  hooks.register :prepend, :around, *args, &block
end

- (void) before(&block) - (void) before(scope, &block) - (void) before(scope, conditions, &block) - (void) before(conditions, &block) Also known as: append_before

Note:

The :example and :context scopes are also available as :each and :all, respectively. Use whichever you prefer.

Declare a block of code to be run before each example (using :example) or once before any example (using :context). These are usually declared directly in the ExampleGroup to which they apply, but they can also be shared across multiple groups.

You can also use before(:suite) to run a block of code before any example groups are run. This should be declared in RSpec.configure

Instance variables declared in before(:example) or before(:context) are accessible within each example.

Order

before hooks are stored in three scopes, which are run in order: :suite, :context, and :example. They can also be declared in several different places: RSpec.configure, a parent group, the current group. They are run in the following order:

before(:suite)    # declared in RSpec.configure
before(:context)  # declared in RSpec.configure
before(:context)  # declared in a parent group
before(:context)  # declared in the current group
before(:example)  # declared in RSpec.configure
before(:example)  # declared in a parent group
before(:example)  # declared in the current group

If more than one before is declared within any one scope, they are run in the order in which they are declared.

Conditions

When you add a conditions hash to before(:example) or before(:context), RSpec will only apply that hook to groups or examples that match the conditions. e.g.

RSpec.configure do |config|
  config.before(:example, :authorized => true) do
     :authorized_user
  end
end

describe Something, :authorized => true do
  # the before hook will run in before each example in this group
end

describe SomethingElse do
  it "does something", :authorized => true do
    # the before hook will run before this example
  end

  it "does something else" do
    # the hook will not run before this example
  end
end

Warning: before(:suite, :with => :conditions)

The conditions hash is used to match against specific examples. Since before(:suite) is not run in relation to any specific example or group, conditions passed along with :suite are effectively ignored.

Exceptions

When an exception is raised in a before block, RSpec skips any subsequent before blocks and the example, but runs all of the after(:example) and after(:context) hooks.

Warning: implicit before blocks

before hooks can also be declared in shared contexts which get included implicitly either by you or by extension libraries. Since RSpec runs these in the order in which they are declared within each scope, load order matters, and can lead to confusing results when one before block depends on state that is prepared in another before block that gets run later.

Warning: before(:context)

It is very tempting to use before(:context) to speed things up, but we recommend that you avoid this as there are a number of gotchas, as well as things that simply don't work.

context

before(:context) is run in an example that is generated to provide group context for the block.

instance variables

Instance variables declared in before(:context) are shared across all the examples in the group. This means that each example can change the state of a shared object, resulting in an ordering dependency that can make it difficult to reason about failures.

unsupported rspec constructs

RSpec has several constructs that reset state between each example automatically. These are not intended for use from within before(:context):

  • let declarations
  • subject declarations
  • Any mocking, stubbing or test double declaration

other frameworks

Mock object frameworks and database transaction managers (like ActiveRecord) are typically designed around the idea of setting up before an example, running that one example, and then tearing down. This means that mocks and stubs can (sometimes) be declared in before(:context), but get torn down before the first real example is ever run.

You can create database-backed model objects in a before(:context) in rspec-rails, but it will not be wrapped in a transaction for you, so you are on your own to clean up in an after(:context) block.

Examples:

before(:example) declared in an ExampleGroup


describe Thing do
  before(:example) do
    @thing = Thing.new
  end

  it "does something" do
    # here you can access @thing
  end
end

before(:context) declared in an ExampleGroup


describe Parser do
  before(:context) do
    File.open(file_to_parse, 'w') do |f|
      f.write <<-CONTENT
        stuff in the file
      CONTENT
    end
  end

  it "parses the file" do
    Parser.parse(file_to_parse)
  end

  after(:context) do
    File.delete(file_to_parse)
  end
end

Overloads:

  • - (void) before(scope, &block)

    Parameters:

    • scope (Symbol)

      :example, :context, or :suite (defaults to :example)

  • - (void) before(scope, conditions, &block)

    Parameters:

    • scope (Symbol)

      :example, :context, or :suite (defaults to :example)

    • conditions (Hash)

      constrains this hook to examples matching these conditions e.g. before(:example, :ui => true) { ... } will only run with examples or groups declared with :ui => true.

  • - (void) before(conditions, &block)

    Parameters:

    • conditions (Hash)

      constrains this hook to examples matching these conditions e.g. before(:example, :ui => true) { ... } will only run with examples or groups declared with :ui => true.

See Also:



184
185
186
# File 'lib/rspec/core/hooks.rb', line 184

def before(*args, &block)
  hooks.register :append, :before, *args, &block
end

- (void) prepend_before(*args, &block)

Adds block to the front of the list of before blocks in the same scope (:example, :context, or :suite).

See #before for scoping semantics.



194
195
196
# File 'lib/rspec/core/hooks.rb', line 194

def prepend_before(*args, &block)
  hooks.register :prepend, :before, *args, &block
end