Ruby MiniTest Cheat Sheet, Unit and Spec reference

Dan — Fri, 29 Mar 2013 21:19:00 +0000

Ruby’s standard testing suite, MiniTest, is in dire need of a quick-and-handy reference for its syntax. I’ve put one together comparing the unit syntax (assert/refute) and the spec syntax (must/wont). You can see it below or download the Google Spreadsheet I made and roll your own sheet (HTML, XLS)

Test syntax

Unit	Spec	Arguments	Examples
`assert_empty refute_empty`	`must_be_empty wont_be_empty`	`obj, msg=nil`	`assert_empty []` `refute_empty [1,2,3]` `[].must_be_empty` `[1,2,3].wont_be_empty`
`assert_equal refute_equal`	`must_equal wont_equal`	`exp, act, msg=nil`	`assert_equal 2, 2` `refute_equal 2,1` `2.must_equal 2` `2.wont_equal 1`
`assert_in_delta refute_in_delta`	`must_be_within_delta wont_be_within_delta`	`exp, act, dlt=0.001, msg=nil`	`assert_in_delta 2012, 2010, 2` `refute_in_delta 2012, 3012, 2` `2012.must_be_within_delta 2010, 2` `2012.wont_be_within_delta 3012, 2`
	`must_be_close_to wont_be_close_to`	`act, dlt=0.001, msg=nil`	`2012.must_be_close_to 2010, 2` `2012.wont_be_close_to 3012, 2`
`assert_in_epsilon refute_in_epsilon`	`must_be_within_epsilon wont_be_within_epsilon`	`a, b, eps=0.001, msg=nil`	`assert_in_epsilon 1.0, 1.02, 0.05` `refute_in_epsilon 1.0, 1.06, 0.05` `1.0.must_be_within_epsilon 1.02, 0.05` `1.0.wont_be_within_epsilon 1.06, 0.05`
`assert_includes refute_includes`	`must_include wont_include`	`collection, obj, msg=nil`	`assert_includes [1, 2], 2` `refute_includes [1, 2], 3` `[1, 2].must_include 2` `[1, 2].wont_include 3`
`assert_instance_of refute_instance_of`	`must_be_instance_of wont_be_instance_of`	`klass, obj, msg=nil`	`assert_instance_of String, "bar"` `refute_instance_of String, 100` `"bar".must_be_instance_of String` `100.wont_be_instance_of String`
`assert_kind_of refute_kind_of`	`must_be_kind_of wont_be_kind_of`	`klass, obj, msg=nil`	`assert_kind_of Numeric, 100` `refute_kind_of Numeric, "bar"` `100.must_be_kind_of Numeric` `"bar".wont_be_kind_of Numeric`
`assert_match refute_match`	`must_match wont_match`	`exp, act, msg=nil`	`assert_match /\d/, "42"` `refute_match /\d/, "foo"` `"42".must_match /\d/` `"foo".wont_match /\d/`
`assert_nil refute_nil`	`must_be_nil wont_be_nil`	`obj, msg=nil`	`assert_nil [].first` `refute_nil [1].first` `[].first.must_be_nil` `[1].first.wont_be_nil`
`assert_operator refute_operator`	`must_be wont_be`	`o1, op, o2, msg=nil`	`assert_operator 1, :<, 2` `refute_operator 1, :>, 2` `1.must_be :<, 2` `1.wont_be :>, 2`
`assert_output`	`must_output`	`stdout = nil, stderr = nil`	`assert_output("hi\n"){ puts "hi" }` `Proc.new{puts "hi"}.must_output "hi\n"`
`assert_raises`	`must_raise`	`*exp`	`assert_raises(NoMethodError){ nil! }` `Proc.new{nil!}.must_raise NoMethodError`
`assert_respond_to refute_respond_to`	`must_respond_to wont_respond_to`	`obj, meth, msg=nil`	`assert_respond_to "foo",:empty?` `refute_respond_to 100, :empty?` `"foo".must_respond_to :empty?` `100.wont_respond_to :empty?`
`assert_same refute_same`	`must_be_same_as wont_be_same_as`	`exp, act, msg=nil`	`assert_same :foo, :foo` `refute_same ['foo'], ['foo']` `:foo.must_be_same_as :foo` `['foo'].wont_be_same_as ['foo']`
`assert_silent`	`must_be_silent`	`-`	`assert_silent{ 1 + 1 }` `Proc.new{ 1 + 1}.must_be_silent`
`assert_throws`	`must_throw`	`sym, msg=nil`	`assert_throws(:up){ throw :up}` `Proc.new{throw :up}.must_throw :up`

Test Setup

Unit	Spec
`setup()`	`before(type = nil, &block)`
`teardown()`	`after(type = nil, &block)`

Mocks

via MiniTest::Mock

expect(name, retval, args=[]) – Expect that method name is called, optionally with args or a blk, and returns retval.

Example:

@mock.expect(:meaning_of_life, 42)
@mock.meaning_of_life # => 42

@mock.expect(:do_something_with, true, [some_obj, true])
@mock.do_something_with(some_obj, true) # => true

@mock.expect(:do_something_else, true) do |a1, a2|
   a1 == "buggs" && a2 == :bunny
end

verify – Verify that all methods were called as expected. Raises MockExpectationError if the mock object was not called as expected.

Other syntax

def flunk(msg=nil)
def pass(msg=nil)
def skip(msg=nil, bt=caller)
def it (desc="anonymous", &block)
i_suck_and_my_tests_are_order_dependent!() – Call this at the top of your tests when you absolutely positively need to have ordered tests. In doing so, youâ€™re admitting that you suck and your tests are weak. (TestCase public class method)
parallelize_me!() – Call this at the top of your tests when you want to run your tests in parallel. In doing so, youâ€™re admitting that you rule and your tests are awesome.
make_my_diffs_pretty!() – Make diffs for this TestCase use pretty_inspect so that diff in assert_equal can be more details. NOTE: this is much slower than the regular inspect but much more usable for complex objects.

Tutorials

Reference

The post Ruby MiniTest Cheat Sheet, Unit and Spec reference appeared first on danwin.com.