Don’t Mock
Yourself Out
David Chelimsky
Articulated Man, Inc

http://martinfowler.com/articles/mocksArentStubs.html

Classical and
Mockist Testing

Classical and
Mockist Testing

Classical and
Mockist Testing

classicist mockist

merbist railsist

rspecist testunitist

ist bin ein
red herring

The big issue here
is when to use a
mock
http://martinfowler.com/articles/mocksArentStubs.html

agenda
๏ overview of stubs and mocks
๏ mocks/stubs applied to rails
๏ guidelines and pitfalls
๏ questions

test double

test stub
describe Statement do
it \"uses the customer name in the header\" do
customer = stub(\"customer\")
customer.stub(:name).and_return('Joe Customer')
statement = Statement.new(customer)
statement.header.should == \"Statement for Joe Customer\"
end
end

test stub
describe Statement do
it \"uses the customer name in the header\" do
customer = stub(\"customer\")
customer.stub(:name).and_return('Joe Customer')
statement = Statement.new(customer)
statement.header.should == \"Statement for Joe Customer\"
end
end

test stub
describe Statement do
it \"uses the customer name in the header\" do
customer = stub(\"customer\")
customer.stub(:name).and_return('Joe Customer')
statement = Statement.new(customer)
statement.header.should == \"Statement for Joe Customer\"
end
end

test stub
describe Statement do
it \"uses the customer name in the header\" do
customer = stub(\"customer\")
customer.stub(:name).and_return('Joe Customer')
statement = Statement.new(customer)
statement.header.should == \"Statement for Joe Customer\"
end
end

mock object
describe Statement do
it \"logs a message when printed\" do
customer = stub(\"customer\")
customer.stub(:name).and_return('Joe Customer')
logger = mock(\"logger\")
statement = Statement.new(customer, logger)
logger.should_receive(:log).with(/Joe Customer/)
statement.print
end
end

mock object
describe Statement do
it \"logs a message when printed\" do
customer = stub(\"customer\")
customer.stub(:name).and_return('Joe Customer')
logger = mock(\"logger\")
statement = Statement.new(customer, logger)
logger.should_receive(:log).with(/Joe Customer/)
statement.print
end
end

mock object
describe Statement do
it \"logs a message when printed\" do
customer = stub(\"customer\")
customer.stub(:name).and_return('Joe Customer')
logger = mock(\"logger\")
statement = Statement.new(customer, logger)
logger.should_receive(:log).with(/Joe Customer/)
statement.print
end
end

mock object
describe Statement do
it \"logs a message when printed\" do
customer = stub(\"customer\")
customer.stub(:name).and_return('Joe Customer')
logger = mock(\"logger\")
statement = Statement.new(customer, logger)
logger.should_receive(:log).with(/Joe Customer/)
statement.print
end
end

mock object
describe Statement do
it \"logs a message when printed\" do
customer = stub(\"customer\")
customer.stub(:name).and_return('Joe Customer')
logger = mock(\"logger\")
statement = Statement.new(customer, logger)
logger.should_receive(:log).with(/Joe Customer/)
statement.print
end
end

method level
concepts

describe Statement do
it \"logs a message when printed\" do
customer = Object.new
logger = Object.new
customer.stub(:name).and_return('Joe Customer')
statement = Statement.new(customer, logger)
logger.should_receive(:log).with(/Joe Customer/)
statement.print
end
end

describe Statement do
it \"logs a message when printed\" do
customer = Object.new
logger = Object.new
customer.stub(:name).and_return('Joe Customer')
statement = Statement.new(customer, logger)
logger.should_receive(:log).with(/Joe Customer/)
statement.print
end
end

describe Statement do
it \"logs a message when printed\" do
customer = Object.new
logger = Object.new
customer.stub(:name).and_return('Joe Customer')
statement = Statement.new(customer, logger)
logger.should_receive(:log).with(/Joe Customer/)
statement.print
end
end

method stub
describe Statement do
it \"logs a message when printed\" do
customer = Object.new
logger = Object.new
customer.stub(:name).and_return('Joe Customer')
statement = Statement.new(customer, logger)
logger.should_receive(:log).with(/Joe Customer/)
statement.print
end
end

describe Statement do
it \"logs a message when printed\" do
customer = Object.new
logger = Object.new
customer.stub(:name).and_return('Joe Customer')
statement = Statement.new(customer, logger)
logger.should_receive(:log).with(/Joe Customer/)
statement.print
end
end

message expectation
describe Statement do
it \"logs a message when printed\" do
customer = Object.new
logger = Object.new
customer.stub(:name).and_return('Joe Customer')
statement = Statement.new(customer, logger)
logger.should_receive(:log).with(/Joe Customer/)
statement.print
end
end

things aren’t always
as they seem

describe Statement do
it \"uses the customer name in the header\" do
customer = mock(\"customer\")
statement = Statement.new(customer)
customer.should_receive(:name).and_return('Joe Customer')
statement.header.should == \"Statement for Joe Customer\"
end
end
class Statement
def header
\"Statement for #{@customer.name}\"
end
end

describe Statement do
it \"uses the customer name in the header\" do
customer = mock(\"customer\")
statement = Statement.new(customer)
customer.should_receive(:name).and_return('Joe Customer')
statement.header.should == \"Statement for Joe Customer\"
end
end
class Statement
def header
\"Statement for #{@customer.name}\"
end
end

describe Statement do
it \"uses the customer name in the header\" do
customer = mock(\"customer\")
statement = Statement.new(customer)
customer.should_receive(:name).and_return('Joe Customer')
statement.header.should == \"Statement for Joe Customer\"
end
end
class Statement
def header
\"Statement for #{@customer.name}\"
end
end

describe Statement do
it \"uses the customer name in the header\" do
customer = mock(\"customer\")
statement = Statement.new(customer)
customer.should_receive(:name).and_return('Joe Customer')
statement.header.should == \"Statement for Joe Customer\"
end
end
class Statement
def header
\"Statement for #{@customer.name}\"
end
end

describe Statement do
it \"uses the customer name in the header\" do
customer = mock(\"customer\")
statement = Statement.new(customer)
customer.should_receive(:name).and_return('Joe Customer')
statement.header.should == \"Statement for Joe Customer\"
end
end
message
expectation
class Statement
def header
\"Statement for #{@customer.name}\"
end
end

describe Statement do
it \"uses the customer name in the header\" do
customer = mock(\"customer\")
statement = Statement.new(customer)
customer.should_receive(:name).and_return('Joe Customer')
statement.header.should == \"Statement for Joe Customer\"
end
end
bound to
implementation
class Statement
def header
\"Statement for #{@customer.name}\"
end
end

describe Statement do
it \"uses the customer name in the header\" do
customer = stub(\"customer\")
customer.stub(:name).and_return('Joe Customer')
statement = Statement.new(customer)
statement.header.should == \"Statement for Joe Customer\"
end
end
class Statement
def header
\"Statement for #{@customer.name}\"
end
end

describe Statement do
it \"uses the customer name in the header\" do
customer = stub(\"customer\")
customer.stub(:name).and_return('Joe Customer')
statement = Statement.new(customer)
statement.header.should == \"Statement for Joe Customer\"
end
end
class Statement
def header
\"Statement for #{@customer.name}\"
end
end

describe Statement do
it \"uses the customer name in the header\" do
customer = stub(\"customer\")
customer.stub(:name).and_return('Joe Customer')
statement = Statement.new(customer)
statement.header.should == \"Statement for Joe Customer\"
end
end
class Statement
def header
\"Statement for #{@customer.name}\"
end
end

describe Statement do
it \"uses the customer name in the header\" do
customer = stub(\"customer\")
customer.stub(:name).and_return('Joe Customer')
statement = Statement.new(customer)
statement.header.should == \"Statement for Joe Customer\"
end
end
class Statement
def header
\"Statement for #{@customer.name}\"
end
end

describe Statement do
it \"uses the customer name in the header\" do
customer = stub(\"customer\")
customer.stub(:name).and_return('Joe Customer')
statement = Statement.new(customer)
statement.header.should == \"Statement for Joe Customer\"
end
end
????
class Statement
def header
\"Statement for #{@customer.name}\"
end
end

describe Statement do
it \"uses the customer name in the header\" do
customer = stub(\"customer\")
customer.stub(:name).and_return('Joe Customer')
statement = Statement.new(customer)
statement.header.should == \"Statement for Joe Customer\"
end
end
message
expectation
class Statement
def header
\"Statement for #{@customer.name}\"
end
end

describe Statement do
it \"uses the customer name in the header\" do
customer = stub(\"customer\")
customer.stub(:name).and_return('Joe Customer')
statement = Statement.new(customer)
statement.header.should == \"Statement for Joe Customer\"
end
end
bound to
implementation
class Statement
def header
\"Statement for #{@customer.name}\"
end
end

stubs are often
used like mocks

mocks are often
used like stubs

we verify stubs by
checking state after
an action

we tell mocks to
verify interactions

sometimes stubs
just make the
system run

when are
method stubs
helpful?

isolation from
non-determinism

random values

random values
class BoardTest < MiniTest::Unit::TestCase
def test_allows_move_to_last_square
board = Board.new(
:squares => 50,
:die => MiniTest::Mock.new.expect('roll', 2)
)
piece = Piece.new
board.place(piece, 48)
board.move(piece)
assert board.squares[48].contains?(piece)
end
end

time
describe Event do
it \"is not happening before the start time\" do
now = Time.now
start = now + 1
Time.stub(:now).and_return now
event = Event.new(:start => start)
event.should_not be_happening
end
end

isolation from
external dependencies

network access
Database
Interface Database
Subject
Network
Internets
Interface

network access
def test_successful_purchase_sends_shipping_message
ActiveMerchant::Billing::Base.mode = :test
gateway = ActiveMerchant::Billing::TrustCommerceGateway.new(
:login => 'TestMerchant', :password => 'password'
)
item = stub()
messenger = mock()
messenger.expects(:ship).with(item)
purchase = Purchase.new(gateway, item, credit_card, messenger)
purchase.finalize
end

network access
Stub
Database
Code Subject
Example
Stub
Network

network access
def test_successful_purchase_sends_shipping_message
gateway = stub()
gateway.stubs(:authorize).returns(
ActiveMerchant::Billing::Response.new(true, \"ignore\")
)
item = stub()
messenger = mock()
messenger.expects(:ship).with(item)
purchase = Purchase.new(gateway, item, credit_card, messenger)
purchase.finalize
end

polymorphic
collaborators

strategies
describe Employee do
it \"delegates pay() to payment strategy\" do
payment_strategy = mock()
employee = Employee.new(payment_strategy)
payment_strategy.expects(:pay)
employee.pay
end
end

mixins/plugins
describe AgeIdentifiable do
describe \"#can_vote?\" do
it \"raises if including does not respond to birthdate\" do
object = Object.new
object.extend AgeIdentifiable
expect { object.can_vote? }.to raise_error(
/must supply a birthdate/
)
end
it \"returns true if birthdate == 18 years ago\" do
object = Object.new
stub(object).birthdate {18.years.ago.to_date}
object.extend AgeIdentifiable
object.can_vote?.should be(true)
end
end
end

when are
message expectations
helpful?

side effects
describe Statement do
it \"logs a message when printed\" do
customer = stub(\"customer\")
customer.stub(:name).and_return('Joe Customer')
logger = mock(\"logger\")
statement = Statement.new(customer, logger)
logger.should_receive(:log).with(/Joe Customer/)
statement.print
end
end

caching
describe ZipCode do
it \"should only validate once\" do
validator = mock()
zipcode = ZipCode.new(\"02134\", validator)
validator.should_receive(:valid?).with(\"02134\").once.
and_return(true)
zipcode.valid?
zipcode.valid?
end
end

interface discovery
describe \"thing I'm working on\" do
it \"does something with some assistance\" do
thing_i_need = mock()
thing_i_am_working_on = ThingIAmWorkingOn.new(thing_i_need)
thing_i_need.should_receive(:help_me).and_return('what I need')
thing_i_am_working_on.do_something_complicated
end
end

isolation testing

specifying/testing
individual
objects in isolation

good fit with lots of
little objects

all of these
concepts apply to
the non-rails
specific parts of
our rails apps

isolation testing the
rails-specific parts
of our applicationss

V
M
C

View
Controller
Model

Browser
Router
View
Controller
Model
Database

rails testing
๏ unit tests
๏ functional tests
๏ integration tests

rails unit tests
๏ model classes (repositories)
๏ model objects
๏ database

rails functional tests
๏ model classes (repositories)
๏ model objects
๏ database
๏ views
๏ controllers

rails functional tests
๏ model classes (repositories)
๏ model objects
๏ database
๏ views
๏ controllers

rails functional tests
๏ model classes (repositories)
๏ model objects
!DRY
๏ database
๏ views
๏ controllers

rails integration tests
๏ model classes (repositories)
๏ model objects
๏ database
๏ views
๏ controllers
๏ routing/sessions

rails integration tests
๏ model classes (repositories)
๏ model objects
๏ database
!DRY
๏ views
๏ controllers
๏ routing/sessions

the BDD approach

inherited from XP

customer specs
developer specs

rails integration tests
+ webrat
shoulda, context,
micronaut, etc

customer specs are
implemented as
end to end tests

developer specs
are implemented as
isolation tests

mocking and
stubbing
with rails

partials in view specs
describe \"/registrations/new.html.erb\" do
before(:each) do
template.stub(:render).with(:partial => anything)
end
it \"renders the registration navigation\" do
template.should_receive(:render).with(:partial => 'nav')
render
end
it \"renders the registration form \" do
template.should_receive(:render).with(:partial => 'form')
render
end
end

conditional branches in
controller specs
describe \"POST create\" do
describe \"with valid attributes\" do
it \"redirects to list of registrations\" do
registration = stub_model(Registration)
Registration.stub(:new).and_return(registration)
registration.stub(:save!).and_return(true)
post 'create'
response.should redirect_to(registrations_path)
end
end
end

conditional branches in
controller specs
describe \"POST create\" do
describe \"with invalid attributes\" do
it \"re-renders the new form\" do
registration = stub_model(Registration)
Registration.stub(:new).and_return(registration)
registration.stub(:save!).and_raise(
ActiveRecord::RecordInvalid.new(registration))
post 'create'
response.should render_template('new')
end
end
end

conditional branches in
controller specs
describe \"POST create\" do
describe \"with invalid attributes\" do
it \"assigns the registration\" do
registration = stub_model(Registration)
Registration.stub(:new).and_return(registration)
registration.stub(:save!).and_raise(
ActiveRecord::RecordInvalid.new(registration))
post 'create'
assigns[:registration].should equal(registration)
end
end
end

shave a few lines but
leave a little stubble
http://github.com/dchelimsky/stubble

stubble
describe \"POST create\" do
describe \"with valid attributes\" do
it \"redirects to list of registrations\" do
stubbing(Registration) do
post 'create'
response.should redirect_to(registrations_path)
end
end
end
end

stubble
describe \"POST create\" do
describe \"with invalid attributes\" do
it \"re-renders the new form\" do
stubbing(Registration, :as => :invalid) do
post 'create'
response.should render_template('new')
end
end
it \"assigns the registration\" do
stubbing(Registration, :as => :invalid) do
|registration|
post 'create'
assigns[:registration].should equal(registration)
end
end
end
end

chains
describe UsersController do
it \"GET 'best_friend'\" do
member = stub_model(User)
friends = stub()
friend = stub_model(User)
User.stub(:find).and_return(member)
member.stub(:friends).and_return(friends)
friends.stub(:favorite).and_return(friend)
get :best_friend, :id => '37'
assigns[:friend].should equal(friend)
end
end

chains
describe UsersController do
it \"GET 'best_friend'\" do
friend = stub_model(User)
User.stub_chain(:find, :friends, :favorite).
and_return(friend)
get :best_friend, :id => '37'
assigns[:friend].should equal(friend)
end
end

guidlines, pitfalls, and
common concerns

focus on roles
Mock Roles, not Objects
http://www.jmock.org/oopsla2004.pdf

keep things simple

avoid tight coupling

complex setup is a
red flag for design
issues

don’t stub/mock the
object you’re testing

impedes
refactoring

:refactoring => <<-DEFINITION
Improving design
without
changing behaviour
DEFINITION

what is behaviour?

false positives
describe RegistrationsController do
describe \"GET 'pending'\" do
it \"finds the pending registrations\" do
pending_registration = stub_model(Registration)
Registration.should_receive(:pending).
and_return([pending_registration])
get 'pending'
assigns[:registrations].should == [pending_registration]
end
end
end
class RegistrationsController < ApplicationController
def pending
@registrations = Registration.pending
end
end

false positives
describe RegistrationsController do
describe \"GET 'pending'\" do
it \"finds the pending registrations\" do
pending_registration = stub_model(Registration)
Registration.should_receive(:pending).
and_return([pending_registration])
get 'pending'
assigns[:registrations].should == [pending_registration]
end
end
end
class RegistrationsController < ApplicationController
def pending
@registrations = Registration.pending
end
end

false positives
describe Registration do
describe \"#pending\" do
it \"finds pending registrations\" do
Registration.create!
Registration.create!(:pending => true)
Registration.pending.should have(1).item
end
end
end
class Registration < ActiveRecord::Base
named_scope :pending, :conditions => {:pending => true}
end

false positives
describe Registration do
describe \"#pending\" do
it \"finds pending registrations\" do
Registration.create!
Registration.create!(:pending => true)
Registration.pending.should have(1).item
end
end
end
class Registration < ActiveRecord::Base
named_scope :pending, :conditions => {:pending => true}
end

false positives
describe Registration do
describe \"#pending\" do
it \"finds pending registrations\" do
Registration.create!
Registration.create!(:pending => true)
Registration.pending_confirmation.should have(1).item
end
end
end
class Registration < ActiveRecord::Base
named_scope :pending_confirmation, :conditions => {:pending => true}
end

false positives
describe Registration do
describe \"#pending\" do
it \"finds pending registrations\" do
Registration.create!
Registration.create!(:pending => true)
Registration.pending_confirmation.should have(1).item
end
end
end
class Registration < ActiveRecord::Base
named_scope :pending_confirmation, :conditions => {:pending => true}
end

cucumber

http://pragprog.com/titles/achbd/the-rspec-book
http://xunitpatterns.com/
growing object-oriented
Mock Roles, not Objects software, guided by tests
http://www.jmock.org/oopsla2004.pdf http://www.mockobjects.com/book/

http://blog.davidchelimsky.net/
http://www.articulatedman.com/
http://rspec.info/
http://cukes.info/
http://pragprog.com/titles/achbd/the-rspec-book

ruby frameworks

rspec-mocks
http://github.com/dchelimsky/rspec

mocha
http://github.com/floehopper/mocha

flexmock
http://github.com/jimweirich/flexmock

rr
http://github.com/btakita/rr

not a mock
http://github.com/notahat/not_a_mock