A Big Look at MiniTest

@markbates
Friday, October 4, 13

good morning
bonjour
goedemorgen

after last night...

a change of topic...

watch mark sleep...

isn’t this nice?

do not disturb

ﬁne, i’ll get up!

hire me*(consulting only)

PIRATE13
www.metacasts.tv

MiniTest

#
Running
tests:

...........................................

Finished
tests
in
1.851323s,
1.6014
tests/s,
6.7781
assertions/s.

43
tests,
182
assertions,
0
failures,
0
errors,
0
skips

Step 1:
Setup Testing Framework

• RSpec
• MiniTest
• test-unit
• Bacon
• Riot
• Wrong
• Shindo
• testrocket
• rubydoctest
• Testy
• Micronaut
• Kintama
• dtf
• assert
• test_inline
• Lemon
• Detest

Good Things Come in Small Packages

require
'minitest/autorun'

class
Foo

def
add(x,
y)

x
+
y

end
end

describe
Foo
do

describe
'#add'
do

it
'adds
two
numbers'
do

Foo.new.add(4,
2).must_equal
6

end

end
end

require
'minitest/autorun'

class
Foo

def
add(x,
y)

x
+
y

end
end

class
TestFoo
<
MiniTest::Unit::TestCase

def
test_add

assert_equal
6,
Foo.new.add(4,
2)

end
end

IT SHIPS WITH
RUBY!!!

also available as a gem

Familiar Syntax to RSpec or Test::Unit

MiniTest replaced Test::Unit in 1.9

The Basics

MiniTest::Spec

describe
Something
do

end

describe
Something
do

it
"does
something"
do

#
tests
go
here

end

end

describe
Something
do

before
do

#
setup
code
goes
here

end

after
do

#
tear
down
code
goes
here

end

it
"does
something"
do

#
tests
go
here

end

end

describe
Something
do

describe
'something
else'
do

it
"does
something"
do

#
tests
go
here

end

end

end

describe
Something
do

let(:something)
{
Something.new(name:
'Widget')
}

describe
'something
else'
do

it
"does
something"
do

something.name.must_equal
'Widget'

end

end

end

describe
Something
do

subject
{
Something.new(name:
'Widget')
}

describe
'something
else'
do

it
"does
something"
do

subject.name.must_equal
'Widget'

end

end

end

describe
Something
do

subject
{
Something.new(name:
'Widget')
}

context
'something
else'
do

it
"does
something"
do

subject.name.must_equal
'Widget'

end

end

end

scrap.rb:19:in
`block
in
<main>':
undefined
method
`context'
for
#<Class:
0x007fce92074b40>
(NoMethodError)

from
/Users/markbates/.../lib/minitest/spec.rb:71:in
`class_eval'

from
/Users/markbates/.../lib/minitest/spec.rb:71:in
`describe'

from
scrap.rb:15:in
`<main>'

class
MiniTest::Spec

end

class
MiniTest::Spec

class
<<
self

alias
:context
:describe

end

end

describe
Something
do

it
'does
something'

end

describe
Something
do

it
'does
something'

it
'does
something
else'
do

skip

end

end

describe
Something
do

it
'does
something'

it
'does
something
else'
do

skip

end

it
'does
another
thing'
do

skip
"here's
some
reason
why"

end

end

#
Running
tests:

SSS

Finished
tests
in
0.000912s,
3289.4737
tests/s,

0.0000
assertions/s.

3
tests,
0
assertions,
0
failures,
0
errors,
3
skips


Expectations

• must_be
• must_be_close_to
• must_be_empty
• must_be_instance_of
• must_be_kind_of
• must_be_nil
• must_be_same_as
• must_be_silent
• must_be_within_epsilon
• must_equal
• must_include
• must_match
• must_output
• must_respond_to
• must_raise
• must_send
• must_throw

• wont_be
• wont_be_close_to
• wont_be_empty
• wont_be_instance_of
• wont_be_kind_of
• wont_be_nil
• wont_be_same_as
• wont_be_silent
• wont_be_within_epsilon
• wont_equal
• wont_include
• wont_match
• wont_output
• wont_respond_to
• wont_raise
• wont_send
• wont_throw

describe
Something
do

it
"does
something"
do

lambda
{nil
/
2}.must_raise
NoMethodError

["one",
"two"].must_include
"one"

["one",
"two"].wont_include
"three"

nil.must_be_nil

[].must_be
:empty?

end

end

MiniTest::Unit

class
TestSomething
<

end

class
TestSomething
<

def
test_something

#tests
go
here

end

end

class
TestSomething
<

def
setup

#
setup
code
goes
here

end

def
teardown

#
tear
down
code
goes
here

end

def
test_something

#
tests
go
here

end

end

class
TestSomething
<

def
test_something

assert
true

end

end

class
TestSomething
<

def
test_something

assert
true

end

class
TestSomethingElse
<

def
test_something_else

assert
true

end

end

end

No subject

class
SomethingTest
<

end

class
SomethingTest
<

def
test_something

skip

end

end

class
SomethingTest
<

def
test_something

skip

end

def
test_something_else

skip
"here's
some
reason
why"

end

end

#
Running
tests:

SS

Finished
tests
in
0.000663s,
3016.5913
tests/s,

0.0000
assertions/s.

2
tests,
0
assertions,
0
failures,
0
errors,
2
skips

Assertions

• assert
• assert_block
• assert_empty
• assert_equal
• assert_in_delta
• assert_in_epsilon
• assert_includes
• assert_instance_of
• assert_kind_of
• assert_match
• assert_nil
• assert_operator
• assert_output
• assert_raises
• assert_respond_to
• assert_same
• assert_send
• assert_silent

• refute
• refute_block
• refute_empty
• refute_equal
• refute_in_delta
• refute_in_epsilon
• refute_includes
• refute_instance_of
• refute_kind_of
• refute_match
• refute_nil
• refute_operator
• refute_output
• refute_raises
• refute_respond_to
• refute_same
• refute_send
• refute_silent

Mocking/Stubbing

Very Basic

describe
Something
do

let(:something)
{
MiniTest::Mock.new
}

it
"does
something"
do

end

end

describe
Something
do

let(:something)
{
MiniTest::Mock.new
}

it
"does
something"
do

something.expect(:name,
'Widget')

end

end

describe
Something
do

let(:something)
{
MiniTest::Mock.new
}

it
"does
something"
do

'Widget')

'Widget'

end

end

describe
Something
do

let(:something)
{
MiniTest::Mock.new
}

it
"does
something"
do

'Widget')

'Widget'

something.verify

end

end

describe
Something
do

let(:something)
{
MiniTest::Mock.new
}

it
"does
something"
do

'Widget')

something.verify

end

end

#
Running
tests:

E

Finished
tests
in
0.000858s,
1165.5012
tests/s,
0.0000

assertions/s.

1)
Error:
OpenStruct#test_0001_does
something:
MockExpectationError:
expected
name()
=>
"Widget",
got
[]

scrap.rb:22:in
`block
(2
levels)
in
<main>'

1
tests,
0
assertions,
0
failures,
1
errors,
0
skips


describe
Something
do

let(:something)
{
Something.new(name:
'Widget')
}

it
"does
something"
do

end

end

describe
Something
do

let(:something)
{
Something.new(name:
'Widget')
}

it
"does
something"
do

something.stub(:name,
'Thingy')
do

end

end

end

describe
Something
do

let(:something)
{
Something.new(name:
'Widget')
}

it
"does
something"
do

something.stub(:name,
'Thingy')
do

'Thingy'

end

end

end

Struct, OpenStruct

describe
"Something"
do

let(:something)
{
OpenStruct.new(name:
'Widget')
}

it
"does
something"
do

'Widget'

end

end

describe
Something
do

let(:something)
{
Something.new(name:
'Widget')
}

it
"does
something"
do

'Thingy'

end

end

describe
Something
do

let(:something)
{
Something.new(name:
'Widget')
}

it
"does
something"
do

def
something.name

"Thingy"

end

'Thingy'

end

end

Mocha, RR, FlexMock

Custom
Assertions

describe
Something
do

it
"does
something"
do

1.2.must_round_to
1

1.7.wont_round_to
1

end

end

module
MiniTest::Assertions

end


module

def
assert_equals_rounded(rounded,
decimal)

end

end


module

def
decimal)

assert
rounded
==
decimal.round,
"Expected
#{decimal}
to
round
to
#{rounded}"

end

end


module

def
decimal)

assert
rounded
==
decimal.round,
"Expected
#{decimal}
to
round
to
#{rounded}"

end

def
refute_equals_rounded(rounded,
decimal)

end

end


module

def
decimal)

assert
rounded
==
decimal.round,
"Expected
#{decimal}
to
round
to
#{rounded}"

end

def
decimal)

assert
rounded
!=
decimal.round,
"Expected
#{decimal}
to
not
round
to
#{rounded}"

end

end


module

def
decimal)

assert
rounded
==
decimal.round,
"Expected
#{decimal}
to
round
to
#{rounded}"

end

def
decimal)

assert
rounded
!=
decimal.round,
"Expected
#{decimal}
to
not
round
to
#{rounded}"

end

end

Numeric.infect_an_assertion
:assert_equals_rounded,
:must_round_to
Numeric.infect_an_assertion
:refute_equals_rounded,
:wont_round_to

gem “minitest-rails”

ENV["RAILS_ENV"]
=
"test"
require
File.expand_path("../../config/environment",
__FILE__)
require
"rails/test_help"
require
"minitest/rails"

#
Add
`gem
"minitest-‐rails-‐capybara"`
to
the
test
group
of
your
Gemfile
#
and
uncomment
the
following
if
you
want
Capybara
feature
tests
#
require
"minitest/rails/capybara"


ENV["RAILS_ENV"]
=
"test"
require
__FILE__)
require
"rails/test_help"
require
"minitest/rails"

#
Add
`gem
to
the
test
group
of
your
Gemfile
#
and
uncomment
the
following
if
you
want
Capybara
feature
tests
#
require

class
ActiveSupport::TestCase

#
Add
more
helper
methods
to
be
used
by
all
tests
here...

before
do

end

after
do

end

end

ENV["RAILS_ENV"]
=
"test"
require
__FILE__)
require
"rails/test_help"
require
"minitest/rails"

#
Add
`gem
to
the
test
group
of
your
Gemfile
#
and
uncomment
the
following
if
you
want
Capybara
feature
tests
#
require

module
MiniTest::Expectations

infect_an_assertion
:assert_redirected_to,
:must_redirect_to

infect_an_assertion
:assert_template,
:must_render_template

infect_an_assertion
:assert_response,
:must_respond_with
end

class
ActiveSupport::TestCase

#
Add
more
helper
methods
to
be
used
by
all
tests
here...

before
do

end

after
do

end

end

rake
minitest

#
Run
default
tests
rake
minitest:all

#
Run
all
tests
rake
minitest:all:quick

#
Run
all
tests,
ungrouped
for
quicker
execution
rake
minitest:controllers

#
Runs
tests
under
test/controllers
rake
minitest:lib

#
Runs
tests
under
test/lib
rake
minitest:models

#
Runs
tests
under
test/models

task
:mt
=>
'minitest:all:quick'
Rake::Task["default"].clear
task
:default
=>
:mt

ruby
-‐I
test
test/models/user_test.rb

describe
FeedController
do

describe
'#index'
do

it
'renders
an
atom
feed'
do

get
:index

must_render_template
:index

end

it
'redirects
from
an
RSS
feed'
do

get
:index,
format:
'rss'

must_redirect_to
feed_path(format:
:atom)

end

end

end

gem “guard-minitest”

guard
:minitest
do

watch(%r|âpp/controllers/(.*).rb|)
{
|m|
"test/controllers/#{m[1]}_test.rb"
}

watch(%r|âpp/helpers/(.*).rb|)

{
|m|
"test/helpers/#{m[1]}_test.rb"
}

watch(%r|âpp/models/(.*).rb|)

{
|m|
"test/models/#{m[1]}_test.rb"
}

watch(%r{^test/test_helper.rb})

{
'test'
}

watch(%r{^test/.+_test.rb})

watch(%r{âpp/(.+).rb})

{
|m|
"test/#{m[1]}_test.rb"
}

watch(%r{âpp/controllers/application_controller.rb})
{
'test/controllers'
}

watch(%r{^lib/(.+).rb})

{
|m|
"test/lib/#{m[1]}_test.rb"
}
end

gem “m”

m
test/models/user_test.rb:37

gem “minitest-rails-capybara”

feature
"Can
Access
Home"
do

scenario
"has
content"
do

visit
root_path

assert
page.has_content?("Home#index")

end

end

Wrapping Up

familiar syntax

95% of RSpec

lightweight

rspec
(2.14.1)

rspec-‐core
(~>
2.14.0)

rspec-‐expectations
(~>
2.14.0)

rspec-‐mocks
(~>
2.14.0)
rspec-‐core
(2.14.5)
rspec-‐expectations
(2.14.2)

diff-‐lcs
(>=
1.1.3,
<
2.0)

Ships with Ruby!

• https://github.com/seattlerb/minitest
• http://www.mattsears.com/articles/2011/12/10/minitest-quick-reference
• http://blog.arvidandersson.se/2012/03/28/minimalicous-testing-in-ruby-1-9
• https://github.com/blowmage/minitest-rails-capybara
• https://github.com/guard/guard-minitest
• https://github.com/qrush/m
• http://www.metacasts.tv/casts/minitest-spec
• http://www.metacasts.tv/casts/minitest-rails
• http://www.metacasts.tv/casts/testing-sinatra

Thanks!
@markbates
www.metacasts.tv

A Big Look at MiniTest

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a A Big Look at MiniTest

Semelhante a A Big Look at MiniTest (13)

Mais de Mark

Mais de Mark (18)

Último

Último (20)

A Big Look at MiniTest