Ruby on Rails on Minitest

Transcription

1 Ruby on Rails on Minitest 1

2 Setting Expectations Introductory Talk. Very Little Code. Not going to teach testing or TDD. What & why, not how. 218 Slides, 5.45 SPM. 2

3 WTF is minitest? 3

4 What is Minitest? Replacement for ruby 1.8 s test/unit. Originally 90 lines of code, only test/unit basics. Available as a gem, and ships with ruby & up. Meant to be small, clean, and very fast. Now ~1600 loc, unit, spec, benchmarks, mock/stub, plugins, etc. 4

5 6 Parts of Minitest runner The heart of the machine minitest/unit TDD API minitest/spec BDD API minitest/mock Simple mocking API minitest/pride IO pipelining example minitest/bench Abstract benchmark API 5

6 2 Parts of Minitest runner The heart of the machine minitest/unit TDD API minitest/spec BDD API minitest/mock Simple mocking API minitest/pride IO pipelining example minitest/bench Abstract benchmark API 6

7 minitest/test 7

8 Test Cases are Classes 8

9 Tests are Methods 9

10 Test Example require "minitest/autorun" class TestThingy < Minitest::Test def test_do_the_thing assert_equal 42, Thingy.do_the_thing end end 10

11 Test Example require "minitest/autorun" Simple Subclass class TestThingy < Minitest::Test def test_do_the_thing assert_equal 42, Thingy.do_the_thing end end 10

12 Test Example require "minitest/autorun" Simple Subclass class TestThingy < Minitest::Test def test_do_the_thing assert_equal 42, Thingy.do_the_thing end end Simple Method 10

13 Test Example require "minitest/autorun" Simple Subclass class TestThingy < Minitest::Test def test_do_the_thing assert_equal 42, Thingy.do_the_thing end end Simple Method Magic Free! 10

14 Positive Assertions assert assert_kind_of assert_respond_to assert_empty assert_match assert_same assert_equal assert_nil assert_send* assert_in_delta assert_operator assert_silent*+ assert_in_epsilon+ assert_output*+ assert_throws* assert_includes+ assert_instance_of assert_predicate+ assert_raises* 11 +not in testunit *no negative equiv

15 Negative Assertions refute+ refute_kind_of+ refute_respond_to+ refute_empty+ refute_match refute_same refute_equal refute_nil refute_send refute_in_delta+ refute_operator+ refute_silent refute_in_epsilon+ refute_output refute_throws refute_includes+ refute_instance_of+ refute_predicate+ refute_raises 12 +not in testunit

16 Why all these extra assertions? They're more expressive! assert! obj refute obj assert collection.include? obj assert_includes obj, collection out, err = capture_io do do_something end assert_equal "output", out assert_equal "", err assert_output "output", "" do do_something end 13

17 assert_equal diffs: 1) Failure: test_failing_simple(testsimple) [example.rb:8]: Expected: 42 Actual: 24 2) Failure: test_failing_complex(testcomplex) [example.rb:23]: --- expected +++ actual -22,7 +22,7 "line 22", "line 23", "line 24", - "line 25", + "something unexpected", "line 26", "line 27", "line 28", 14

18 But... 15

19 Where is refute_raises? 16

20 Same place as refute_silent. 17

21 refute_silent This block of code must print something. What it is, I don't care. How is this assertion of value to anyone? Assert for the specific output you need. 18

22 refute_silent This block of code must print something. What it is, I don't care. How is this assertion of value to anyone? Assert for the specific output you need. 19

23 refute_raises This block of code must do something. What it is, I don't care. How is this assertion of value to anyone? Assert for the specific result you need. 20

24 It's Useful No it isn't. Implies side effects and/or return values have been checked. Or aren't important (always false otherwise, why write the code?). Falsely bumps code coverage metrics. False sense of security. 21

25 It's More Expressive No it isn't. Writing the test was the act of expression. It is an explicit contract in any test framework that unhandled exceptions are an error. The test's mere existence explicitly states: "there are no unhandled exceptions via these pathways". 22

26 I've been having this argument for years 23

27 Some people will never be convinced 24

28 Stand Back 25

29 def check_everything assert_something_output do assert_nothing_raised do assert_some_side_effect do assert_some_response do yield end end end end end 26

30 def check_everything assert_something_output do assert_nothing_raised do assert_some_side_effect do assert_some_response do yield end end end end end 2015 Ryan Davis All Rights Reserved ISO 9001 Enterprise Certified Available for $$$$ 26

31 27

32 minitest/spec 28

33 Testing DSL 29

34 Test Cases are `describe` blocks 30

35 Tests are `it` blocks 31

36 Spec Example require "minitest/autorun" describe Thingy do it "must do the thing" do _(Thingy.do_the_thing).must_equal 42 end end 32

37 But 33

38 In Reality 34

39 `describe` blocks are Classes 35

40 `it` blocks are Methods 36

41 Spec Example require "minitest/autorun" describe Thingy do it "must do the thing" do _(Thingy.do_the_thing).must_equal 42 end end 37

42 Specs Transform: require "minitest/autorun" class TestThingy < Minitest::Test def test_0001_must_do_the_thing _(Thingy.do_the_thing).must_equal 42 end end 38

43 Specs Transform: require "minitest/autorun" Simple Subclass class TestThingy < Minitest::Test def test_0001_must_do_the_thing _(Thingy.do_the_thing).must_equal 42 end end 38

44 Specs Transform: require "minitest/autorun" Simple Subclass class TestThingy < Minitest::Test def test_0001_must_do_the_thing _(Thingy.do_the_thing).must_equal 42 end end Simple Method 38

45 Specs Transform: require "minitest/autorun" Simple Subclass class TestThingy < Minitest::Test def test_0001_must_do_the_thing _(Thingy.do_the_thing).must_equal 42 end end Simple Method Magic Free! 38

46 Positive 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_delta must_be_within_epsilon must_equal must_include must_match must_output* must_raise* must_respond_to must_send* must_throw* 39

47 Negative Expectations 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_delta wont_be_within_epsilon wont_equal wont_include wont_match wont_output wont_raise wont_respond_to wont_send wont_throw 40

48 All for Free must_equal is assert_equal wont_equal is refute_equal etc. 41

49 Advanced Testing 42

50 Randomization Baked In 43

51 Preventing Test Order Dependencies 44

52 parallelize_me! 45

53 Use gem, not stdlib Randomize Test Order 5 4 Write custom assertions 6 7 Refactor to reusable testcases 8 Benchmark Tests Turn up the test + spec 3 9 Forced Parallelization Disallow meaningless assertions 2 Fast Test Runner ??? Require Proof of Success? test levels 46

54 Design Rationale 47

55 It's Just Ruby 48

56 Look! Ruby! require "minitest/autorun" class TestThingy < Minitest::Test def test_do_the_thing assert_equal 42, Thingy.do_the_thing end end 49

57 Less is More 50

58 assert_in_delta def assert_in_delta e, a, d = 0.001, m = nil n = (e - a).abs msg = message(m) { "... failure message..." } assert delta >= n, msg end 51

59 assert_in_delta def assert_in_delta e, a, d = 0.001, m = nil n = (e - a).abs msg = message(m) { "... failure message..." } assert delta >= n, msg end message takes a block to defer calculation until an assertion fails 51

60 assert_in_delta def assert_in_delta e, a, d = 0.001, m = nil n = (e - a).abs msg = message(m) { "... failure message..." } assert delta >= n, msg end message takes a simple assertion is all that is needed block to defer calculation until an assertion fails 51

61 assert_in_delta def assert_in_delta e, a, d = 0.001, m = nil n = (e - a).abs msg = message(m) { "... failure message..." } assert delta >= n, msg end Only 2 other methods need to be understood: assert (9) & message (6) simple assertion is all that is needed message takes a block to defer calculation until an assertion fails 51

62 Indirection is the Enemy 52

63 Just 2 Hops module Minitest::Expectation def must_equal(*args) ctx.assert_equal(*args) end end module Minitest::Assertions def assert_equal exp, act, msg = nil msg = message(msg, E) { diff exp, act } assert exp == act, msg end end 53

64 No Magic Allowed 54

65 Thriving Plugin Ecosystem minitest-chef-handler minitest-metadata minitest-reporters minitest-rails-capybara minitest-rails minitest-matchers guard-minitest capybara_minitest_spec minitest-spec-rails minitest-colorize minitest-capybara minitest-rg spork-minitest minitest-ci (& many more) 55

66 Rails & Minitest 56

67 The Official Rails Stack uses Minitest 57

68 Each Release 58

69 Peels back the testing onion 59

70 Encouraging better testing practices 60

71 Peeling onions make you cry 61

72 Right? 62

73 (Hopefully) Not Here 63

74 Rails 4.0 minitest 4.x 64

75 Impact? Zero 65

76 Rails 4.1 minitest 5.x 66

77 Impact? Zero 67

78 Rails 4.2 random order 68

79 Some Impact? 69

80 Good Thing! 70

81 Future Rails Should track minitest. 71

82 As a Rails Dev 72

83 What does all of this mean? 73

84 Hopefully... 74

85 Nothing 75

86 ActiveSupport ::TestCase 76

87 Basic Architecture Minitest::Test ActiveSupport::TestCase MyThingyTest 77

88 Per-test database transactions 78

89 Fixtures # In fixtures/categories.yml about: name: About # In fixtures/articles.yml one: title: Welcome to Rails! body: Hello world! category: about 79

90 Declarative Forms setup do end #... teardown do end #... test test name do end #... 80

91 Extra Assertions assert_difference assert_valid_keys assert_deprecated assert_nothing_raised 81

92 Wait? What?!? 82

93 Don't Worry! def assert_nothing_raised(*args) end yield 83

94 Don't Worry! def assert_nothing_raised(*args) end yield Actual Implementation 83

95 Unit Testing require 'test_helper' class ArticleTest < ActiveSupport::TestCase test "should not save article without title" do article = Article.new refute article.save end end 84

96 ActionController ::TestCase 85

97 Basic Architecture Minitest::Test ActiveSupport::TestCase ActionController::TestCase MyControllerTest 86

98 Actions get post delete etc 87

99 State request response session flash 88

100 Assertions assert_response assert_redirected_to assert_template 89

101 Functional Testing class ArticlesControllerTest < ActionController::TestCase test "should get index" do get :index assert_response :success assert_not_nil assigns(:articles) end end 90

102 ActiveDispatch ::IntegrationTest 91

103 Architecture Minitest::Test ActiveSupport::TestCase ActionDispatch::IntegrationTest MyIntegrationTest 92

104 Assertions Tons 93

105 Integration Testing class UserFlowsTest < ActionDispatch::IntegrationTest test "login and browse site" do https! get "/login" assert_response :success david = users :david post_via_redirect "/login", username: david.username, password: david.password assert_equal '/welcome', path assert_equal 'Welcome david!', flash[:notice] https! false get "/articles/all" assert_response :success assert assigns :articles end end 94

106 guides.rubyonrails.org/ testing.html 95

107 Very Simple 96

108 Very Powerful 97

109 Leverages Minitest 98

110 Test Randomization 99

111 Parallelization 100

112 Enforce Better Testing 101

113 Troubleshooting 102

114 I want to use minitest, but I prefer spec-style 103

115 Simple 104

116 minitest-rails 105

117 minitest-spec-rails 106

118 Lets you do this: describe User do let(:user) { User.create!... } it "does the thing to the stuff" do user.username.must_match(/.../) end end 107

119 I upgraded to rails 4.2 and now I have failures 108

120 AKA: you broke all my shit 109

121 Not as Simple 110

122 Test-Order Dependency Bug 111

123 ran: a, b, c = pass ran: b, a, c = fail 112

124 Easy! 113

125 But, I have hundreds of tests! 114

126 Not so Easy 115

127 minitest-bisect 116

128 Helps you isolate and debug random test failures 117

129 118

130 118

131 I'm used to RSpec + factory-girl + this + that + kitchen sink + everything 119

132 A lot of stuff Just Works 120

133 Look for plugins in readme / gems 121

134 My Suggestion? 122

135 Less Complicated Testing 123

136 Try It 124

137 You Might Like It 125

138 Change Takes Time 126

139 Why use minitest? 127

140 Why Test? aka It slows me down 128

141 Not Going to Bother 129

142 Lost Cause 130

143 I'd rather help other people 131

144 Everyone Uses RSpec 132

145 Obviously Not 133

146 The Official Rails Stack uses Minitest 134

147 DHH uses minitest 135

148 tenderlove uses minitest 136

149 Jeff Casimir & cohort teach minitest at Turing School 137

150 nokogiri, haml, god, newrelic_rpm, sqlite3 138

151 etc 139

152 Functional Differences with RSpec 140

153 Unique Features of RSpec Test metadata & metadata filtering. Implicit subject, described_class, etc. Fancier expectations, negation, etc. before(:all) & around(:each). Shared contexts & example groups. Fancier mocking. Fancier reporting. 141

154 Unique Features of RSpec Test metadata & metadata filtering. Implicit subject, described_class, etc. Fancier expectations, negation, etc. before(:all) & around(:each). Shared contexts & example groups. Fancier mocking. Fancier reporting. 141 Basically, it's Fancier

155 Unique Features of Minitest Unit & Spec Style Testing. Über-Duper fast and lightweight. Easy to understand whole library. minitest/pride. Benchmark tests. First to randomize parallelize_me! & minitest/hell Clean & easy plugin system. Smallest mock/stub framework. 142

156 Unique Features of Minitest Unit & Spec Style Testing. Über-Duper fast and lightweight. Easy to understand whole library. minitest/pride. Benchmark tests. First to randomize parallelize_me! & minitest/hell Clean & easy plugin system. Smallest mock/stub framework. Simple, Pragmatic 142

157 Unique Features of Minitest Unit & Spec Style Testing. Über-Duper fast and lightweight. Easy to understand whole library. minitest/pride. Benchmark tests. First to randomize parallelize_me! & minitest/hell Clean & easy plugin system. Smallest mock/stub framework. Simple, Pragmatic and a bit Snarky 142

158 Cognitive differences with RSpec 143

159 Myron Marston 144

160 Great Comparison 145

161 I'm one of the RSpec developers, and have never used minitest, so take my biases into account when reading this answer. By and large, RSpec's power comes from the fact that it reifies so many testing concepts into first class objects. Where Test::Unit and Minitest use simple methods for making assertions, RSpec uses first-class matcher objects that support negation, self-description and more. RSpec's examples are first-class objects that support rich metadata; minitest/spec compiles it blocks down into simple methods, which don't support the same sort of rich metadata. RSpec supports specifying shared behaviors using a first-class construct (shared example groups) that accepts arguments; w/ minitest you can use inheritance or a mixin to re-use tests, but it doesn't have the same sort of first-class support. RSpec has an explicit formatter API (and there are many third party formatters that use it); I'm not aware of minitest having the same sort of first-class formatter API. As somebody who is constantly running tests and practicing TDD all day long, I find the power RSpec gives me to be very useful. Many people find it to be overkill, though, and there is an added cognitive cost to the extra abstractions. Here are some specific features RSpec has that I believe minitest lacks: before(:all) hooks (note this is a power user feature of RSpec that should rarely be used; I've only used it on a few occasions in many years of using RSpec) around(:each) hooks Shared example groups Shared contexts Rich metadata support that can be used to control which examples get run, which example groups shared contexts get included in, which example groups modules get mixed into and more. 146 Integrated support for a wide range of mocking features w/ rspec-mocks; Minitest::Mock

162 2 Answers I'm one of the RSpec developers, and have never used minitest, so take my biases into account when reading this answer. By and large, RSpec's power comes from the fact that it reifies so many testing concepts into first class objects. Where Test::Unit and Minitest use simple methods for making assertions, RSpec uses first-class matcher objects that support negation, self-description and more. RSpec's examples are first-class objects that support rich metadata; minitest/spec compiles it blocks down into simple methods, which don't support the same sort of rich metadata. RSpec supports specifying shared behaviors using a first-class construct (shared example groups) that accepts arguments; w/ minitest you can use inheritance or a mixin to re-use tests, but it doesn't have the same sort of first-class support. RSpec has an explicit formatter API (and there are many third party formatters that use it); I'm not aware of minitest having the same sort of first-class formatter API. As somebody who is constantly running tests and practicing TDD all day long, I find the power RSpec gives me to be very useful. Many people find it to be overkill, though, and there 146

163 Ruby on Rails on Minitest Apparently, 147

164 Ruby on Rails on Minitest Apparently, 147

165 TL;DR 148

166 By and large, RSpec's power comes from the fact that it reifies so many testing concepts into first class objects. Where Test::Unit and Minitest use simple methods for making assertions, RSpec uses first-class matcher objects that support negation, self-description and more. RSpec's examples are firstclass objects that support rich metadata; minitest/spec compiles it blocks down into simple methods, which don't support the same sort of rich metadata. RSpec supports specifying shared behaviors using a first-class construct (shared example groups) that accepts arguments; w/ minitest you can use inheritance or a mixin to re-use tests, but it doesn't have the same sort of firstclass support

167 Myron thinks this is why RSpec is great 150

168 I think it is everything wrong with RSpec 151

169 We're Both Right 152

170 "Do I contradict myself? Very well, then I contradict myself, I am large, I contain multitudes." Walt Whitman 153

171 By and large, RSpec's power comes from the fact that it reifies so many testing concepts into first class objects. Where Test::Unit and Minitest use simple methods for making assertions, RSpec uses first-class matcher objects that support negation, self-description and more. RSpec's examples are firstclass objects that support rich metadata; minitest/spec compiles it blocks down into simple methods, which don't support the same sort of rich metadata. RSpec supports specifying shared behaviors using a first-class construct (shared example groups) that accepts arguments; w/ minitest you can use inheritance or a mixin to re-use tests, but it doesn't have the same sort of firstclass support

172 Minitest RSpec Example Groups Examples Reuse Expectations 155 * my interpretation, not a quote

173 Minitest RSpec Example Groups compiles describe blocks down into simple classes* reifies testing concepts into first class objects* Examples Reuse Expectations 155 * my interpretation, not a quote

174 Minitest RSpec Example Groups compiles describe blocks down into simple classes* reifies testing concepts into first class objects* Examples compiles it blocks down into simple methods examples are first-class objects Reuse Expectations 155 * my interpretation, not a quote

175 Minitest RSpec Example Groups compiles describe blocks down into simple classes* reifies testing concepts into first class objects* Examples compiles it blocks down into simple methods examples are first-class objects Reuse you can use inheritance or a mixin specifying shared behaviors using a first-class construct Expectations 155 * my interpretation, not a quote

176 Minitest RSpec Example Groups compiles describe blocks down into simple classes* reifies testing concepts into first class objects* Examples compiles it blocks down into simple methods examples are first-class objects Reuse you can use inheritance or a mixin specifying shared behaviors using a first-class construct Expectations use simple methods for making assertions uses first-class matcher objects 155 * my interpretation, not a quote

177 Minitest RSpec Example Groups compiles describe blocks down into simple methods reifies testing concepts into first class objects Examples compiles it blocks down into simple methods examples are first-class objects Reuse you can use inheritance or a mixin specifying shared behaviors using a first-class construct Expectations use simple methods for making assertions uses first-class matcher objects 156

178 Minitest RSpec compiles describe blocks Example Groups Class 1st Class Object down into simple methods reifies testing concepts into first class objects Examples compiles it blocks down into simple methods examples are first-class objects Reuse you can use inheritance or a mixin specifying shared behaviors using a first-class construct Expectations use simple methods for making assertions uses first-class matcher objects 156

179 Minitest RSpec compiles describe blocks Example Groups Class 1st Class Object down into simple methods reifies testing concepts into first class objects compiles it blocks down into Examples Method 1st Class Object simple methods examples are first-class objects Reuse you can use inheritance or a mixin specifying shared behaviors using a first-class construct Expectations use simple methods for making assertions uses first-class matcher objects 156

180 Minitest RSpec compiles describe blocks Example Groups Class 1st Class Object down into simple methods reifies testing concepts into first class objects compiles it blocks down into Examples Method 1st Class Object simple methods examples are first-class objects you can use inheritance or a Reuse Subclass or Include 1st Class Object mixin specifying shared behaviors using a first-class construct Expectations use simple methods for making assertions uses first-class matcher objects 156

181 Minitest RSpec compiles describe blocks Example Groups Class 1st Class Object down into simple methods reifies testing concepts into first class objects compiles it blocks down into Examples Method 1st Class Object simple methods examples are first-class objects you can use inheritance or a Reuse Subclass or Include 1st Class Object mixin specifying shared behaviors using a first-class construct use simple methods for Expectations Method Call 1st Class Object making assertions uses first-class matcher objects 156

182 Ruby on Rails on Minitest 1st Class You keep using that term. I do not think it means what you think it means. 157

183 A language construct is said to be a FirstClass value in that language when there are no restrictions on how it can be created and used: when the construct can be treated as a value without restrictions. FirstClass features can be stored in variables, passed as arguments to functions, created within functions and returned from functions. In dynamically typed languages, a FirstClass feature can also have its type examined at run-time

184 Minitest RSpec Example Groups Class 1st Class Object Examples Method 1st Class Object Reuse Subclass or Include 1st Class Object Expectations Method Call 1st Class Object 159

185 Minitest RSpec It's Just Ruby Example Groups Class 1st Class Object Examples Method 1st Class Object Reuse Subclass or Include 1st Class Object Expectations Method Call 1st Class Object 159

186 Minitest RSpec It's Just Ruby Reinvents the Wheel Example Groups Class 1st Class Object Examples Method 1st Class Object Reuse Subclass or Include 1st Class Object Expectations Method Call 1st Class Object 159

187 Nested Describes describe A do before { :a } it "runs :a" describe B do before { :b } it "runs :a, :b" end end 160

188 Nested Describes describe A do Inherited "methods" before { :a } it "runs :a" describe B do before { :b } it "runs :a, :b" end end 160

189 Nested Describes describe A do Inherited "methods" before { :a } it "runs :a" describe B do before { :b } it "runs :a, :b" end end NOT Inherited "methods" 160

190 Are A & B classes? Is Nesting like Subclassing? 161

191 Classes? class TestA < RSpec::Spec def before super :a end class TestB < TestA def before super :b end def test_runs_a; end undef_method :test_runs_a end end def test_runs_a_b; end 162

192 Classes? class TestA < RSpec::Spec def before super :a end class TestB < TestA def before super :b end def test_runs_a; end undef_method :test_runs_a end end def test_runs_a_b; end 162

193 Are before/after like included modules? 163

194 Modules? class TestA < RSpec::Spec module BeforeAfter def setup super if respond_to? :super :a end end class TestB < RSpec::Spec module BeforeAfter def setup super if respond_to? :super :b end end include TestA::BeforeAfter include TestA::BeforeAfter include TestB::BeforeAfter end def test_runs_a; end end def test_runs_a_b; end 164

195 This is basically Another Object Model 165

196 That's Confusing if you're just learning Ruby/OO 166

197 Encourages new users to handwave 167

198 To not know what #describe or #it actually are or do 168

199 Here's the Magic Incantation to do X 169

200 Any sufficiently advanced technology is indistinguishable from magic. A.C. Clarke 170

201 RSpec: It s actually Magic

202 Many people find it to be overkill, though, and there is an added cognitive cost to the extra abstractions. Myron Marsten, from previous post 172

203 Indeed 173

204 */lib Minitest RSpec Multiplier # Files Flog 2, , Lines of Code 1,589 15, Lines of Comment 1,063 7, Comment + Code 2,652 22, Comment/Code N/A 174

205 Flog Minitest RSpec 175

206 30,000 Lines of Code Lines of Comment 22,500 15,000 7,500 0 Minitest RSpec 176

207 177

208 TEST TEST TEST TEST 177

209 TEST TEST TEST vs TEST 177

210 TEST TEST TEST vs TEST 177

211 Many people find it to be overkill, though, and there is an added cognitive cost to the extra abstractions. Myron Marsten, from previous post 178

212 Not just cognitive! 179

213 Performance differences with RSpec 180

214 All those abstractions? 181

215 Reinventing the wheel? 182

216 Has a Real Cost 183

217 Combined RSpec Results Combined Minitest Results pos rs time 1neg rs time 50neg rs time 100neg rs time pos rs memory 1neg rs memory 50neg rs memory 100neg rs memory pos mt time 1neg mt time 50neg mt time 100neg mt time pos mt memory 1neg mt memory 50neg mt memory 100neg mt memory Time (s) Memory (MB) Time (s) Memory (MB) # tests # tests 184

218 Combined RSpec Results Combined Minitest Results pos rs time 1neg rs time 50neg rs time 100neg rs time pos rs memory 1neg rs memory 50neg rs memory 100neg rs memory pos mt time 1neg mt time 50neg mt time 100neg mt time pos mt memory 1neg mt memory 50neg mt memory 100neg mt memory Time (s) Memory (MB) Time (s) Memory (MB) # tests # tests 185

219 But Ryan

220 Who cares? 187

221 Passing rspec is fast enough 188

222 Bug? 189

223 Bug? Refactor? 189

224 Bug? Refactor? Anything else goes wrong? 189

225 You Pay 190

226 For Completeness: 191

227 Minitest vs RSpec, time & memory (assertions) 0.60 mt time rs time 0.45 Expectation Time (s) Speed test, # assertions

228 Minitest vs RSpec, time mt time rs time Method Time (s) 4.50 Execution # tests, 0 assertions Speed

229 Linear 194

230 Don't reduce examples or expectations 195

231 If you want a speed up 196

232 Switch to minitest 197

233 Or never, ever refactor. 198

234 Summary 199

235 At the end of the day 200

236 As long as you test 201

237 I don't care what you use 202

238 Use the best tool for your job 203

239 Hopefully, I've shown 204

240 The technical merits of Minitest 205

241 Choose what works for you 206

242 Not because it seems popular 207

243 Maybe there's fewer articles about MT because there's less need for them? 208

244 MT is much easier to understand. 209

245 MT users aren't missing. 210

246 They're busy Getting Stuff Done. 211

247 Choose what works for you 212

248 Who knows? 213

249 Try It 214

250 You might like it 215

251 After All 216

252 It's Just Ruby 217

253 Thank You 218

254 Thank You (hire me) 218