Mocking and stubbing in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Ruby mocking code?

Consider the following Ruby code using RSpec mocks. What will be printed when this code runs?

Ruby

class User
  def name
    "Alice"
  end
end

user = User.new
allow(user).to receive(:name).and_return("Bob")
puts user.name

A Alice

B RuntimeError

C nil

D Bob

💡 Hint

Think about what allow(...).to receive(...).and_return(...) does to the method.

The allow method replaces the name method on the user object to always return "Bob" instead of the original "Alice".

❓ Predict Output

intermediate

What error does this Ruby stub code raise?

What error will this Ruby code raise when run?

Ruby

class Calculator
  def add(a, b)
    a + b
  end
end

calc = Calculator.new
allow(calc).to receive(:add).with(1, 2).and_return(5)
puts calc.add(2, 3)

A 5

B 5.0

C 3

D RSpec::Mocks::MockExpectationError

💡 Hint

Check what arguments the stub expects and what arguments are actually passed.

The stub only affects calls to add with arguments 1, 2. Calling add(2, 3) runs the original method, returning 5.

🔧 Debug

advanced

Why does this stub not work as expected?

Look at this Ruby code snippet using RSpec mocks. Why does the stub not change the method output?

Ruby

class Dog
  def bark
    "woof"
  end
end

dog = Dog.new
allow(Dog).to receive(:bark).and_return("meow")
puts dog.bark

A Because <code>allow</code> was called on the class, not the instance

B Because <code>allow</code> cannot stub methods that return strings

C Because <code>dog.bark</code> is a private method

D Because <code>allow</code> requires a block to work

💡 Hint

Think about the difference between stubbing a class method and an instance method.

The stub was set on the class Dog, but bark is an instance method. The stub does not affect the instance dog.

❓ Predict Output

advanced

What is the output of this chained stub in Ruby?

What will this Ruby code print?

Ruby

class Car
  def engine
    Engine.new
  end
end

class Engine
  def start
    "vroom"
  end
end

car = Car.new
allow(car).to receive_message_chain(:engine, :start).and_return("silent")
puts car.engine.start

A silent

B vroom

C NoMethodError

D nil

💡 Hint

Look at what receive_message_chain does.

The receive_message_chain stub replaces the chained call car.engine.start to return "silent" instead of calling the real methods.

❓ Predict Output

expert

What is the value of the variable after this stubbed method call?

Given the following Ruby code, what is the value of result after execution?

Ruby

class Service
  def fetch_data
    {status: 200, body: "data"}
  end
end

service = Service.new
allow(service).to receive(:fetch_data).and_return({status: 404, body: "not found"})
result = service.fetch_data[:status]

A 200

B 404

C "data"

D nil

💡 Hint

Remember what the stub changes the method to return.

The stub changes fetch_data to return a hash with status: 404, so result is 404.