Let and before hooks in Ruby - Mini Project: Build & Apply

Using Let and Before Hooks in Ruby Tests

📖 Scenario: You are writing tests for a simple Ruby class that manages a list of tasks. To keep your tests clean and organized, you will use let to define reusable variables and before hooks to set up common test conditions.

🎯 Goal: Build a small test suite using let to create a task list and before hooks to add tasks before each test runs.

📋 What You'll Learn

Create a let variable named task_list that initializes an empty array.

Create a before hook that adds the string 'Buy milk' to task_list.

Write a test that checks if task_list includes 'Buy milk'.

Write a test that adds 'Walk dog' to task_list and checks if both tasks are present.

💡 Why This Matters

🌍 Real World

Using <code>let</code> and <code>before</code> hooks is common in Ruby testing frameworks like RSpec to organize test data and setup steps efficiently.

💼 Career

Understanding these concepts helps you write clean, maintainable tests in Ruby projects, a valuable skill for Ruby developers and QA engineers.

1

Create a let variable for the task list

Write a let block named task_list that returns an empty array [].

Ruby

require 'rspec'

RSpec.describe 'Task List' do
  # Create a let block named task_list that returns []
  # Your code here
end

Hint

Use let(:task_list) { [] } inside the RSpec.describe block.

2

Add a before hook to add a task

Add a before block that adds the string 'Buy milk' to task_list using task_list << 'Buy milk'.

Ruby

require 'rspec'

RSpec.describe 'Task List' do
  let(:task_list) { [] }

  # Add a before block that adds 'Buy milk' to task_list
  # Your code here
end

Hint

Use before do ... end and inside it add task_list << 'Buy milk'.

3

Write a test to check the initial task

Write an it block with description 'includes Buy milk' that expects task_list to include 'Buy milk' using expect(task_list).to include('Buy milk').

Ruby

require 'rspec'

RSpec.describe 'Task List' do
  let(:task_list) { [] }

  before do
    task_list << 'Buy milk'
  end

  # Write an it block named 'includes Buy milk' that checks task_list includes 'Buy milk'
  # Your code here
end

Hint

Use it 'includes Buy milk' do ... end and inside use expect(task_list).to include('Buy milk').

4

Write a test to add and check multiple tasks

Write an it block with description 'adds Walk dog and checks both tasks' that adds 'Walk dog' to task_list and expects task_list to include both 'Buy milk' and 'Walk dog' using two expect statements.

Ruby

require 'rspec'

RSpec.describe 'Task List' do
  let(:task_list) { [] }

  before do
    task_list << 'Buy milk'
  end

  it 'includes Buy milk' do
    expect(task_list).to include('Buy milk')
  end

  # Write an it block named 'adds Walk dog and checks both tasks'
  # Add 'Walk dog' to task_list and check both tasks are included
  # Your code here
end

Hint

Inside the it block, add task_list << 'Walk dog' and two expect lines to check both tasks.

Practice

1. What is the main purpose of using let in Ruby tests?

easy

A. To create reusable values that are lazily evaluated

B. To run setup code before each test

C. To define a test case

D. To clean up after tests run

Solution

1. Step 1: Understand let behavior

   let defines a value that is created only when needed (lazy evaluation) and reused within the same test.

2. Step 2: Differentiate from before

   before runs code before each test but does not create reusable values like let.

3. Final Answer:

   To create reusable values that are lazily evaluated -> Option A

4. Quick Check:

   let = reusable lazy value [OK]

Hint: Remember: let creates values, before runs code [OK]

Common Mistakes:

• Confusing let with before hook
• Thinking let runs before each test eagerly
• Assuming let defines test cases

2. Which of the following is the correct syntax to define a let variable named user with value "Alice"?

easy

A. before { user = "Alice" }

B. let user = "Alice"

C. let(:user) { "Alice" }

D. let user { "Alice" }

Solution

1. Step 1: Recall let syntax

   let takes a symbol argument and a block returning the value: let(:name) { value }.

2. Step 2: Check each option

   let(:user) { "Alice" } matches correct syntax. Options B and D miss parentheses or block syntax. before { user = "Alice" } uses before, not let.

3. Final Answer:

   let(:user) { "Alice" } -> Option C

4. Quick Check:

   Correct let syntax uses symbol and block [OK]

Hint: Use parentheses and block for let: let(:name) { value } [OK]

Common Mistakes:

• Omitting parentheses around symbol
• Using assignment instead of block
• Confusing let with before syntax

3. Given the code below, what will be printed when the test runs?

let(:count) { 0 }
before { count += 1 }
it "increments count" do
  puts count
end

medium

A. 0

B. 1

C. 2

D. Error: undefined method += for nil

Solution

1. Step 1: Understand let and before interaction

   let(:count) { 0 } defines a method returning 0. But count is not a variable; it's a method call.

2. Step 2: Analyze before { count += 1 }

   count += 1 tries to modify count as a variable, but count is a method, so Ruby raises an error: undefined method += for nil or no local variable.

3. Final Answer:

   Error: undefined method += for nil -> Option D

4. Quick Check:

   Cannot modify let method return with += [OK]

Hint: let defines methods, not variables; += fails on method calls [OK]

Common Mistakes:

• Assuming let creates a variable to modify
• Expecting count to increment automatically
• Ignoring that let is lazily evaluated method

4. Identify the error in the following test setup:

let(:numbers) { [1, 2, 3] }
before do
  numbers << 4
end
it "checks numbers length" do
  expect(numbers.length).to eq(4)
end

medium

A. Modifying let value causes shared state between tests

B. No error; test passes as expected

C. Syntax error in let definition

D. before block runs after the test

Solution

1. Step 1: Understand let and before execution order

   let(:numbers) memoizes a new array [1,2,3] the first time numbers is called in each test example.

2. Step 2: Trace the test execution

   In before, numbers << 4 calls/memoizes numbers and mutates it to [1,2,3,4]. In it, numbers.length (memoized) is 4, so test passes.

3. Final Answer:

   No error; test passes as expected -> Option B

4. Quick Check:

   Mutation in before(:each) affects per-example memoized let correctly [OK]

Hint: let memoizes per example; before mutation visible consistently in test [OK]

Common Mistakes:

• Misunderstanding per-example memoization (no inter-test sharing)
• Thinking mutation always causes shared state between tests
• Confusing before(:each) with before(:all)

5. You want to test a user object that requires setup before each test and a reusable user name. Which is the best way to combine let and before hooks?

let(:user_name) { "Bob" }
before do
  @user = User.new(name: user_name)
  @user.activate!
end
it "checks user is active" do
  expect(@user.active?).to be true
end

What is the main advantage of this approach?

hard

A. Separates reusable data (user_name) from setup actions (before)

B. Runs let block after before hook

C. Avoids using instance variables for test data

D. Ensures user_name is reset after each test

Solution

1. Step 1: Analyze separation of concerns

   let(:user_name) defines reusable data lazily, while before runs setup code creating and activating user.

2. Step 2: Understand benefits

   This keeps data definition and setup logic cleanly separated, improving test readability and maintainability.

3. Final Answer:

   Separates reusable data (user_name) from setup actions (before) -> Option A

4. Quick Check:

   let for data, before for setup [OK]

Hint: Use let for data, before for setup steps [OK]

Common Mistakes:

• Thinking let runs before before hook
• Avoiding instance variables unnecessarily
• Confusing reset behavior of let