- Defined in:
#before(&block) ⇒ void #before(scope, &block) ⇒ void #before(scope, conditions, &block) ⇒ void #before(conditions, &block) ⇒ void Also known as: append_before
:context scopes are also available as
:all, respectively. Use whichever you prefer.
:suite scope is only supported for hooks registered on
RSpec.configuration since they exist independently of any
example or example group.
Declare a block of code to be run before each example (using
or once before any example (using
:context). These are usually
declared directly in the 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 .
Instance variables declared in
are accessible within each example.
before hooks are stored in three scopes, which are run in order:
: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.
When you add a conditions hash to
before(:context), RSpec will only apply that hook to groups or
examples that match the conditions. e.g.
. do |config| config.before(:example, :authorized => true) do log_in_as :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
Note that filtered config
:context hooks can still be applied
to individual examples that have matching metadata. Just like
Ruby's object model is that every object has a singleton class
which has only a single instance, RSpec's model is that every
example has a singleton example group containing just the one
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.
When an exception is raised in a
before block, RSpec skips any
before blocks and the example, but runs all of the
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.
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.
before(:context) is run in an example that is generated to provide
group context for the block.
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
- Any mocking, stubbing or test double declaration
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
You can create database-backed model objects in a
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
197 198 199
# File 'lib/rspec/core/hooks.rb', line 197 def before(*args, &block) hooks.register :append, :before, *args, &block end