Let and before hooks in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of let and before hook variable usage

What is the output of this Ruby RSpec code snippet?

Ruby

RSpec.describe 'Example' do
  let(:number) { 5 }

  before do
    @result = number * 2
  end

  it 'calculates result' do
    puts @result
  end
end

A 10

B 5

C Error: undefined local variable or method `number`

D nil

💡 Hint

Remember that let defines a memoized helper method accessible in before blocks.

The let(:number) defines a method returning 5. The before block runs before the test and sets @result to number * 2, which is 10. The test prints 10.

🧠 Conceptual

intermediate

Scope of let variables in before hooks

Which statement about let variables and before hooks in RSpec is true?

A <code>let</code> variables are eagerly evaluated before <code>before</code> hooks run.

B <code>let</code> variables are only accessible inside <code>it</code> blocks, not <code>before</code> hooks.

C <code>let</code> variables cannot be accessed inside <code>before</code> hooks.

D <code>let</code> variables are lazily evaluated and can be accessed inside <code>before</code> hooks.

💡 Hint

Think about when let variables get evaluated.

let variables are lazily evaluated the first time they are called. Since before hooks run before it blocks, accessing a let variable inside a before hook triggers its evaluation.

❓ Predict Output

advanced

Effect of multiple before hooks on let variable

What will be printed when running this RSpec test?

Ruby

RSpec.describe 'Multiple before hooks' do
  let(:counter) { @count ||= 0; @count += 1 }

  before do
    counter
  end

  before do
    counter
  end

  it 'prints counter value' do
    puts counter
  end
end

A 1

B 2

C 3

D Error: undefined method `count` for nil:NilClass

💡 Hint

Remember that let is memoized per example and evaluated once.

The let(:counter) is evaluated once per example. The first before calls it, setting @count to 1. The second before calls it again but uses the memoized value 1. The it block prints 1.

🔧 Debug

advanced

let declared after before hook

What will this RSpec code produce?

Ruby

RSpec.describe 'Error example' do
  before do
    @value = number * 3
  end

  let(:number) { 4 }

  it 'prints value' do
    puts @value
  end
end

A SyntaxError due to let after before

B No error, prints 12

C NilClass error when multiplying

D NameError: undefined local variable or method `number`

💡 Hint

In RSpec, declaration order of let and before does not affect method availability.

In RSpec, let(:number) defines the method during the describe block evaluation, before examples or hooks run. Thus, number is available in the before block, @value is set to 12, and the test prints 12 with no error.

🚀 Application

expert

Predict final value after multiple let and before hooks

Given this RSpec code, what is the final value of @total printed?

Ruby

RSpec.describe 'Complex let and before' do
  let(:base) { 10 }

  before do
    @total = base + 5
  end

  before do
    @total += base
  end

  it 'prints total' do
    puts @total
  end
end

A 20

B 15

C 25

D Error: undefined method `base`

💡 Hint

Think about how let is evaluated and how @total changes in each before block.

The first before sets @total = base + 5 → 15. The second before adds base again → 15 + 10 = 25. The test prints 25.