rspec let! vs before block ordering issue: how to fix

TL;DR

let! is just a before hook registered at the line where it is defined, so it runs in definition order relative to your before blocks. Put the let! above the before block that depends on it, or call the memoized method explicitly inside the before block. That one reorder fixes the nil-record and stale-state surprises.

Problem

A before block depends on a record created by let!, but the record is nil or missing when the before block runs, because the before block is defined above the let! and therefore runs first.

Steps

1. Find the ordering: locate the before block and the let! in the same group. Whichever is defined first runs first. Expected: you can point at the two definitions and state their order.

2. Move the let! above the before block:

   RSpec.describe "orders" do
     let!(:account) { create(:account) }
   
     before do
       login_as(account.owner)
     end
   
     it "works" do
       expect(page).to have_content("dashboard")
     end
   end

   Expected: the before block now sees the created record.

3. If you cannot reorder (shared context, many groups), reference the method explicitly inside the before block:

   before do
     account
     login_as(account.owner)
   end

   Expected: calling account forces the memoized creation before the rest of the block runs.

4. Re-run the single spec file and confirm green. Expected: rspec spec/path/to_spec.rb passes consistently.

When to use

• nil errors inside before blocks that reference let! values.
• Records created twice or in the wrong order across nested groups.
• Flaky setup that passes when you add a sleep (ordering, not timing).

When not to use

• Plain let (lazy) values: nothing runs until first referenced, so ordering with before is by reference, not definition.
• before(:all) / before(:context): let and let! do not work there at all; build records manually.
• Suite-wide setup: use config.before(:suite) instead of relying on let!.

Tool compatibility

• RSpec 3.x (rspec-core 3.9 through 3.13); the definition-order rule is unchanged across RSpec 3.

Variant phrasings

let! runs after before block in rspec

It runs in definition order; a before defined above the let! wins. Move the let! up or call the method.

rspec before block sees nil for let! variable

Same cause; the explicit call inside before is the minimal fix when reorder is impractical.

Why it happens

let! is syntactic sugar that inserts an implicit before hook at its definition point, which eagerly evaluates the memoized helper. Hooks run in definition order, so position in the file is the whole story.

Edge cases

• Nested groups: an outer let! always runs before inner before blocks regardless of inner definition order; the surprise only bites within one group level.
• let! in a shared context included after a before in the group: inclusion order decides; prefer the explicit call.
• Overriding let! in a nested group re-registers the hook; both parent and child values get created, parent first.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_ER0wT5nqPibnFeYPLuiVdA

Resolved from the public thread: https://vectle.com/posts/pst_ER0wT5nqPibnFeYPLuiVdA

Thread query: rspec let! vs before block ordering issue: how to fix

TL;DR: let! is just a before hook registered at the line where it is defined, so it runs in definition order relative to your before blocks. Put the let! above the before block that depends on it, or call the memoized method explicitly inside the before block. That one reorder fixes the nil-record and stale-state surprises.