I'm pleased to introduce a new Test Double (or mock) framework named RR, which is short for Double Ruby.
Why a Double framework and not a Mock framework?
A mock is a type of test double. Since RR supports mocks, stubs, and proxies, it makes sense to refer to RR as a double framework. The proxy is a new usage pattern that I will introduce later in this article, and in more detail in future articles.
Unfortunately, the terminology over doubles has been contradictory depending on the framework. RR's terminology tries to be as faithful as possible to Gerald Meszaros' definition of test doubles. You can read more about test doubles in XUnit Test Patterns and Martin Fowler's article, Mocks aren't Stubs. Regretfully, this does mean that RR will have slightly different terminology than other double frameworks.
How does RR compare to other Mock frameworks?
Most double frameworks focus mainly on mocks (hence the categorization "mock framework"). RR's focus is on enabling more double test patterns in a terse and readable syntax.
RR also does not have dedicated mock objects. It primarily uses the technique called 'double injection'. Names that other frameworks use are 'stub injection', 'mock object injection', 'partial mocking', or 'stubbing'. The term I'll use for this is a double injection, since one or many doubles are being injected into an object's method.
I'll use trivial Rails examples to highlight the syntactical differences between RR, Mocha, Rspec's mocks, and Flexmock. They may or may not be appropriate situations for mocks. The right situations for mocks is an entirely different discussion.
If there is better way to do any of the examples, please post a comment and I will gladly replace it.
Mocks
Here are the ways to mock the User.find method. The expectation is the User class object will receive a call to #find with the argument '99' once and will return the object represented by the variable user.
RR
mock(User).find('99') { user }
Mocha
User.expects(:find).with('99').returns(user)
spec/mocks
User.should_receive(:find).with('99').and_return(user)
Flexmock
flexstub(User).should_receive(:find).with('99').and_return(user).once
Stubs
Here are the ways to stub the User.find method. When the User class object receives a call to find with the argument '99' it will return user1. When User receives find with any other arg, it returns user2.
RR
stub(User).find('99') { user1 }
stub(User).find { user2 }
Mocha
User.stubs(:find).with(anything).returns(2)
User.stubs(:find).with('99').returns(1)
spec/mocks
users = {
'99' => user1,
'default' => user2
}
User.stub!(:find).and_return do |id|
users[id] || users['default']
end
Flexmock
users = {
'99' => user1,
'default' => user2
}
flexstub(User).should_receive(:find).and_return do |id|
users[id] || users['default']
end
Proxy
A proxy used with a mock or stub causes the real method to be called. Expectations can be placed on the invocation and the return value can be intercepted. The main rationales are test clarity and you can ensure that the methods are being called correctly, even after you refactor your code. I will delve more into proxies and their usage patterns in my next article.
Mock Proxy
The following examples set an expectation that User.find('99') will be called once. The actual user is returned.
RR
mock.proxy(User).find('99')
Mocha
You cannot implement this in Mocha. You can do an approximation in this situation however. This technique is not always the solution you need, though.
user = User.find('99')
User.expects(:find).with('99').returns(user)
spec/mocks
find_method = User.method(:find)
User.should_receive(:find).with('99').and_return(&find_method)
Flexmock
find_method = User.method(:find)
User.should_receive(:find).with('99').and_return(&find_method)
Stub Proxy
The following examples intercept the return value of User.find('99') and stub out valid? to return false.
RR
stub.proxy(User).find('99') do |user|
stub(user).valid? {false}
user
end
Mocha
Again, this is an approximation, since you cannot use proxies in Mocha.
user = User.find('99')
user.stubs(:valid?).returns(false)
User.stubs(:find).with('99').returns(user)
spec/mocks
find_method = User.method(:find)
User.stub!(:find).with('99').and_return do |id|
user = find_method.call(id)
user.stub!(:valid?).and_return(false)
user
end
Flexmock
find_method = User.method(:find)
flexstub(User).should_receive(:find).with('99').and_return do |id|
user = find_method.call(id)
flexstub(user).should_receive(:valid?).and_return(false)
user
end
instance_of
instance_of is method sugar than allows you to mock or stub instances of a particular class. The following examples mock instances of User to expect valid? with no arguments to be called once and return false.
RR
mock.instance_of(User).valid? {false}
Mocha
User.any_instance.expects(:valid?).returns(false)
spec/mocks
new_method = User.method(:new)
User.stub!(:new).and_return do |*args|
user = new_method.call(*args)
user.should_receive(:valid?).and_return(false)
user
end
Flexmock
new_method = User.method(:new)
flexstub(User).should_receive(:new).and_return do |*args|
user = new_method.call(*args)
flexmock(user).should_receive(:valid?).and_return(false)
user
end
More to come
This concludes the introduction to RR. RR enables some techniques, like proxying, that will make your tests clearer and less brittle. In the next article I will describe into patterns and techniques that will make mocks a more feasible tool for more situations.
Interesting Things
- Rails Bug: Test::Unit seems to be broken in Rails 2.0.2 when using multiple levels of test classes (i.e. inheritance). Trunk is fixed, so Rails 2.0.3 will be fine.
Chad wrote a small utility for checking/comparing Rails versions which wraps the version checking part of rubygems. This, of course, requires that your Rails project uses at least one gem... that's a pretty good bet.
The basic technique:
have = Rails::VERSION::STRING requirement = '=1.99.1' Gem::Version::Requirement.new([requirement]).satisfied_by?(Gem::Version.new(have))One pivot is having trouble finding a rogue
putsstatement in a gem somewhere. The suggestion comes a bit late in this case, but adding some breadcrumbs may help next time:puts "#{__FILE__}:#{__LINE__} find me!"
Ask for Help
- Does anyone have details regarding Google Maps API developer permissions? Localhost-to-localhost requests work fine, but we need to test things between machines (actually, a virtual machine client and virtual machine host).
I've found that typing in column mode to be very useful when using editors like IntelliJ or TextMate. VI also has a column edit mode, that is a little tricky to use.
To use it, press:
- Ctrl + V to go into column mode
- Select the columns and rows where you want to enter your text
- Shift + i to go into insert mode in column mode
- Type in the text you want to enter. Dont be discouraged by the fact that only the first row is changed.
- Esc to apply your change (or alternately Ctrl+c)
You will now see your changed applied.
We just implemented bookmark_fu on Pivots and the experience was very smooth, taking only a few minutes. We how have an "Iconistan" of social bookmarking chiclets for either remembering or promoting content on Digg, reddit, del.icio.us -- almost 20 sites in all.
Install via the normal plugin install process (the -x installs it as an SVN:EXTERNAL):
#> ruby script/plugin install -x svn://rubyforge.org/var/svn/pivotalrb/bookmark_fu/trunk/bookmark_fu
I did have one issue -- the script/plugin install script pulled all the code down but ultimately failed because we have multiple versions of Rails on our development machine (about 5); this seemed to confuse the install script. No problem, though: I ran the install.rb script manually:
#> script/runner vendor/plugins/bookmark_fu/install.rb
Interesting Things
- Josh read Coda Hale's interesting blog post about test driving (or rather, RSpec driving) his rake tasks:
I love RSpec, and lately I’ve been making the transition from test-friendly development to full-on spec-driven development… I was working on a project recently which boiled down to “run these tasks in this order,” which is a natural fit for Rake.
Interesting Things
- Video Lunch: Once in a while, you just want to see something cool. So on days when nothing else is going on, we show interesting videos during lunch, such as TED Talks or Videos from the Googleplex. Today, we'll watch these:
Interesting Things
- Rails Bug: composed_of seems to be broken, at least in Rails 1.99. The :mappings parameter states that it can take an array of symbol-pairs, but symbols do not work -- only strings work. Example: Does not work:
composed_of :name
:class_name => Name
:mapping => [
[:first_name, :first], # :symbol, :symbol does not work!
[:last_name, :last] # :symbol, :symbol does not work!
]
Works!
composed_of :name
:class_name => Name
:mapping => [
['first_name', 'first'], # 'string', 'string' works!
['last_name', 'last'] # 'string', 'string' works!
]
- Ruby ain't Java! A recent Java-convert ran into the following: when calling a private instance method, you must not indicate
self.private_method, but instead callprivate_method. Example:
Class PrivateCaller
def call_private_here
puts private_method #=> works!
puts self.private_method #=> self? uh oh!
end
private
def private_method
'*** You Called? ***'
end
end
>> priv = PrivateCaller.new
=> #<privatecaller:0x14ec39c>
>> priv.call_private_here
*** You Called? ***
NoMethodError: private method `private_method' called for #</privatecaller:0x14ec39c><privatecaller:0x14ec39c>
from (irb):4:in `private_caller'
from (irb):23
from :0
</privatecaller:0x14ec39c>
- TextMate's Ruby on Rails bundle does not work correctly with Rails 2.0.
- RubyGems 0.95 is not compatable with geminstaller, written and maintained by our own Chad Woolley. Chad and the Gems folks are already on the case.
Ask for Help
- "Please help feed the hungry of San Francisco."
We helped! Our barrel is over flowing.
Interesting Things
Rails 2.0 *blink* Rails 2.0.1 *blink* Rails 2.0.2 was released. This includes at least one Pivotal patch:
Fix that
validates_acceptance_ofstill works for non-existent tables (useful for bootstrapping new databases). Closes #10474 [hasmanyjosh]Brown bag lunch: Today two folks from Sun will visit to tell us about their Glassfish and JRuby projects.
- We have launched our replacement for Pivotal Blabs -- Pivots, the Pivotal Labs network. This is a showcase for our own social networking platform. Check out everyone's individual blogs here.
- Several projects have written Javascript that catches errors and makes an AJAX call to the server, logging that error for future debugging. More on this later.
Ask for Help
- "Can someone please help me set up my Capistrano 2.0 deploy?"
Sure! He was having an issue with SVN dropping the connection during the initial project setup. Breaking down the command and running each step individually seemed to do the trick. - "Does anyone know a good Chinese delivery option near 3rd and Market?"
Really... any suggestions?
During our Retrospective yesterday, several Pivots, especially our remote employees, mentioned that they missed the Standup blog posts that we used to post. Shall we start to post them again? And if so, does anyone have posting format suggestions? The old posts reflected our current real-life Standup format:
- Introductions
- Ask for Help
- Interesting Things
Unless anyone suggests changes, we'll keep the same format.