The Craft of TDD

This talk was given at PixelsCamp 2016 on the 7th of October. It isn't aimed for the complete novice, it's not really a "how-to", instead it's aimed at those that have heard and looked into TDD and that might have tried it out but gave up because it takes time or didn't initially find it valuable. There will also be things for those that do TDD and are continuing to learn about it.

At the end of the talk I hope to convince you that TDD is actually quite useful, and that you leave with some awareness on how to make writing these tests a bit easier while avoiding some common traps as you continue on this path.

List of recommended resources from the talk: http://bit.ly/the-craft-of-tdd

Transcript

1. Raoul Felix Craft of TDD the
2. the value of TDD on writing tests
3. what’s our goal as developers?
4. deliver value to our users
5. deliver value to our users deliver working software faster
6. deliver value to our users deliver working software faster adapt to user’s changes
7. deliver value to our users deliver working software faster adapt to user’s changes produce quality software
8. you SHOULD* be using TDD *to be interpreted as described in RFC 2119
9. describe “Benefits of TDD” do
10. context “delivering software faster” do describe “Benefits of TDD” do
11. it “is a productive workflow” do describe “Benefits of TDD” do context “delivering software faster” do
12. describe “Benefits of TDD” do context “delivering software faster” do it “is a productive workflow” do green refactor red
13. write code refactor write test describe “Benefits of TDD” do context “delivering software faster” do it “is a productive workflow” do
14. expect( developer.in_the_zone?). to eq(true) describe “Benefits of TDD” do context “delivering software faster” do it “is a productive workflow” do
15. .F Failures: 1) App.current_username is nil by default Failure/Error: expect(App.current_username).to be_nil expected: nil got: "test@example.com" # ./tip_fix_flaky_tests_spec.rb:29:in `block (3 levels) in <top (required)>' Finished in 0.02265 seconds (files took 0.10097 seconds to load) 2 examples, 1 failure Failed examples: rspec ./tip_fix_flaky_tests_spec.rb:28 # App.current_username is nil by default rspec spec/ describe “Benefits of TDD” do context “delivering software faster” do it “is a productive workflow” do
16. it “facilitates working in teams” do describe “Benefits of TDD” do context “delivering software faster” do
17. code as documentation describe “Benefits of TDD” do context “delivering software faster” do it “facilitates working in teams” do
18. detect conflicts in changes describe “Benefits of TDD” do context “delivering software faster” do it “facilitates working in teams” do
19. it “lowers maintenance costs” do describe “Benefits of TDD” do context “delivering software faster” do
20. catch bugs earlier describe “Benefits of TDD” do context “delivering software faster” do it “lowers maintenance costs” do
21. debug issues faster describe “Benefits of TDD” do context “delivering software faster” do it “lowers maintenance costs” do
22. $ rspec --format documentation tdd_benefits_spec.rb:9 Benefits of TDD delivering software faster is a productive workflow lowers maintenance costs facilitates working in teams Finished in 5 minutes and 0.64148 seconds 3 examples, 0 failures
23. context “adapting to user’s changes” do describe “Benefits of TDD” do
24. it “helps produce a better ” do design describe “Benefits of TDD” do context “adapting to user’s changes” do
25. tests are users of your “API” describe “Benefits of TDD” do context “adapting to user’s changes” do it “helps produce a better design” do
26. refactor if pain? describe “Benefits of TDD” do context “adapting to user’s changes” do it “helps produce a better design” do
27. less coupling describe “Benefits of TDD” do context “adapting to user’s changes” do it “helps produce a better design” do
28. immediate feedback describe “Benefits of TDD” do context “adapting to user’s changes” do it “helps produce a better design” do
29. confidence to change the design describe “Benefits of TDD” do context “adapting to user’s changes” do it “helps produce a better design” do
30. it “doesn’t guarantee a good ” do design describe “Benefits of TDD” do context “adapting to user’s changes” do
31. BDUF design no describe “Benefits of TDD” do context “adapting to user’s changes” do it “doesn’t guarantee a good design” do
32. BDUF design no design emergent describe “Benefits of TDD” do context “adapting to user’s changes” do it “doesn’t guarantee a good design” do
33. BDUF design no design emergent not magic requires thinking describe “Benefits of TDD” do context “adapting to user’s changes” do it “doesn’t guarantee a good design” do
34. “Act locally, think globally” Ron Jefferies co-author of XP and an Agile Manifesto signatory describe “Benefits of TDD” do context “adapting to user’s changes” do it “doesn’t guarantee a good design” do
35. describe “good ” do design describe “Benefits of TDD” do context “adapting to user’s changes” do
36. it “follows S.O.L.I.D. principles” do describe “Benefits of TDD” do context “adapting to user’s changes” do describe “good design” do
37. describe “Benefits of TDD” do context “adapting to user’s changes” do describe “good design” do it “follows S.O.L.I.D. principles” do S - Single Responsibility O - Open Closed L - Liskov Substitution I - Interface Segregation D - Dependency Inversion
38. describe “Benefits of TDD” do context “adapting to user’s changes” do describe “good design” do it “follows S.O.L.I.D. principles” do S - Single Responsibility O - Open Closed L - Liskov Substitution I - Interface Segregation D - Dependency Inversion
39. require 'httparty' class IP OK_CODE = 200 IP_SERVICE = 'http://bot.whatismyipaddress.com' def even_or_odd response = HTTParty.get(IP_SERVICE) return unless response.code == OK_CODE ip = response.body.strip if ip.split('.').last.to_i % 2 == 0 'even' else 'odd' end end end ip = IP.new puts "My IP is #{ip.even_or_odd}"
40. require 'httparty' class IP OK_CODE = 200 IP_SERVICE = 'http://bot.whatismyipaddress.com' def even_or_odd response = HTTParty.get(IP_SERVICE) return unless response.code == OK_CODE ip = response.body.strip if ip.split('.').last.to_i % 2 == 0 'even' else 'odd' end end end ip = IP.new puts "My IP is #{ip.even_or_odd}"
41. require 'httparty' class IP OK_CODE = 200 IP_SERVICE = 'http://bot.whatismyipaddress.com' def even_or_odd response = HTTParty.get(IP_SERVICE) return unless response.code == OK_CODE ip = response.body.strip if ip.split('.').last.to_i % 2 == 0 'even' else 'odd' end end end ip = IP.new puts "My IP is #{ip.even_or_odd}"
42. require 'httparty' class IP OK_CODE = 200 IP_SERVICE = 'http://bot.whatismyipaddress.com' def even_or_odd response = HTTParty.get(IP_SERVICE) return unless response.code == OK_CODE ip = response.body.strip if ip.split('.').last.to_i % 2 == 0 'even' else 'odd' end end end ip = IP.new puts "My IP is #{ip.even_or_odd}"
43. require 'httparty' class IP OK_CODE = 200 IP_SERVICE = 'http://bot.whatismyipaddress.com' def even_or_odd response = HTTParty.get(IP_SERVICE) return unless response.code == OK_CODE ip = response.body.strip if ip.split('.').last.to_i % 2 == 0 'even' else 'odd' end end end ip = IP.new puts "My IP is #{ip.even_or_odd}"
44. class WhatIsMyIPAddress OK_CODE = 200 IP_SERVICE = 'http://bot.whatismyipaddress.com' def my_ip response = HTTParty.get(IP_SERVICE) return unless response.code == OK_CODE response.body.strip end end class ClassifyIP def self.call public_ip = WhatIsMyIPAddress.new.my_ip if public_ip.split('.').last.to_i % 2 == 0 'even' else 'odd' end end end
45. class WhatIsMyIPAddress OK_CODE = 200 IP_SERVICE = 'http://bot.whatismyipaddress.com' def my_ip response = HTTParty.get(IP_SERVICE) return unless response.code == OK_CODE response.body.strip end end class ClassifyIP def self.call public_ip = WhatIsMyIPAddress.new.my_ip if public_ip.split('.').last.to_i % 2 == 0 'even' else 'odd' end end end
46. describe “Benefits of TDD” do context “adapting to user’s changes” do describe “good design” do it “follows S.O.L.I.D. principles” do S - Single Responsibility O - Open Closed L - Liskov Substitution I - Interface Segregation D - Dependency Inversion
47. class ClassifyIP def self.call public_ip = WhatIsMyIPAddress.new.my_ip if public_ip.split('.').last.to_i % 2 == 0 'even' else 'odd' end end end describe ClassifyIP do describe ".call" do it "returns 'even' when the IP is divisible by 2" do expect(ClassifyIP.call).to eq('even') end end end
48. class ClassifyIP def self.call public_ip = WhatIsMyIPAddress.new.my_ip if public_ip.split('.').last.to_i % 2 == 0 'even' else 'odd' end end end describe ClassifyIP do describe ".call" do it "returns 'even' when the IP is divisible by 2" do expect(ClassifyIP.call).to eq('even') end end end
49. class ClassifyIP def self.call public_ip = WhatIsMyIPAddress.new.my_ip if public_ip.split('.').last.to_i % 2 == 0 'even' else 'odd' end end end describe ClassifyIP do describe ".call" do it "returns 'even' when the IP is divisible by 2" do expect(ClassifyIP.call).to eq('even') end end end
50. class ClassifyIP def self.call(ip_service = WhatIsMyIpAddress.new) public_ip = ip_service.my_ip if public_ip.split('.').last.to_i % 2 == 0 'even' else 'odd' end end end describe ClassifyIP do describe ".call" do it "returns 'even' when the IP is divisible by 2" do expect(ClassifyIP.call).to eq('even') end end end
51. class ClassifyIP def self.call(ip_service = WhatIsMyIpAddress.new) public_ip = ip_service.my_ip if public_ip.split('.').last.to_i % 2 == 0 'even' else 'odd' end end end describe ClassifyIP do describe ".call" do it "returns 'even' when the IP is divisible by 2" do stub_ip_service = double('Stub IP Service’, my_ip: ‘192.168.2.2') expect( ClassifyIP.call(ip_service: stub_ip_service) ).to eq('even') end end end
52. flexibility
53. puts "My IP is #{ClassifyIP.call}”
54. ip_service = WhatIsMyIPAddress.new puts "My IP is #{ClassifyIP.call(ip_service: ip_service)}”
55. ip_service = WhatIsMyIPAddress.new cached_ip_service = CachedIPService.new(ip_service) puts "My IP is #{ClassifyIP.call(ip_service: cached_ip_service)}”
56. it “follows 4 Rules of Simple Design” do describe “Benefits of TDD” do context “adapting to user’s changes” do describe “good design” do
57. 1 - Passes all tests describe “Benefits of TDD” do context “adapting to user’s changes” do describe “good design” do it “follows 4 Rules of Simple Design” do
58. 1 2 - Passes all tests - Reveals intention describe “Benefits of TDD” do context “adapting to user’s changes” do describe “good design” do it “follows 4 Rules of Simple Design” do
59. 3 - No duplication describe “Benefits of TDD” do context “adapting to user’s changes” do describe “good design” do it “follows 4 Rules of Simple Design” do 1 2 - Passes all tests - Reveals intention
60. 4 - Fewest elements describe “Benefits of TDD” do context “adapting to user’s changes” do describe “good design” do it “follows 4 Rules of Simple Design” do 3 - No duplication 1 2 - Passes all tests - Reveals intention
61. it “favours separation of concerns” do describe “Benefits of TDD” do context “adapting to user’s changes” do describe “good design” do
62. e.g. The Clean Architecture describe “Benefits of TDD” do context “adapting to user’s changes” do describe “good design” do it “favours separation of concerns” do
63. e.g. Hexagonal Architecture describe “Benefits of TDD” do context “adapting to user’s changes” do describe “good design” do it “favours separation of concerns” do app layer domain model user-side adaptors data-side adaptors ui http … db service …
64. $ rspec --format documentation tdd_benefits_spec.rb:24 Benefits of TDD adapting to user’s changes helps produce a better design it doesn’t guarantee a good design good design follows S.O.L.I.D. principles follows 4 Rules of Simple Design favours separation of concerns Finished in 10 minutes and 0.64148 seconds 5 examples, 0 failures
65. context “producing quality software” do describe “Benefits of TDD” do
66. it “helps when writing tests first” do describe “Benefits of TDD” do context “producing quality software” do
67. focused thinking describe “Benefits of TDD” do context “producing quality software” do it “helps when writing tests first” do
68. you define what you want describe “Benefits of TDD” do context “producing quality software” do it “helps when writing tests first” do
69. avoid fragile tests describe “Benefits of TDD” do context “producing quality software” do it “helps when writing tests first” do
70. it “results in a test suite” do describe “Benefits of TDD” do context “producing quality software” do
71. 1 - Classical / Detroit Style TDD describe “Benefits of TDD” do context “producing quality software” do it “results in a test suite” do unit real collaborator
72. describe SayHello do it "returns a greeting using a formatted name" do expect(SayHello.call("John")).to eq("Hello there JOHN!") end end class SayHello def self.call(name) capitalized_name = CapitalizeFormatter.new.format(name) "Hello there #{capitalized_name}!" end end class CapitalizeFormatter def format(name) name.upcase end end
73. describe SayHello do it "returns a greeting using a formatted name" do expect(SayHello.call("John")).to eq("Hello there JOHN!") end end class SayHello def self.call(name) "Hello there #{name.upcase}!” end end class CapitalizeFormatter def format(name) name.upcase end end
74. describe SayHello do it "returns a greeting using a formatted name" do expect(SayHello.call("John")).to eq("Hello there JOHN!") end end class SayHello def self.call(name) capitalized_name = CapitalizeFormatter.new.format(name) "Hello there #{capitalized_name}!" end end class CapitalizeFormatter def format(name) name.upcase end end
75. 1 - Classical / Detroit Style TDD describe “Benefits of TDD” do context “producing quality software” do it “results in a test suite” do SayHello CapitalizedFormatter
76. 1 - Classical / Detroit Style TDD describe “Benefits of TDD” do context “producing quality software” do it “results in a test suite” do “Sociable” Unit Tests SayHello CapitalizedFormatter
77. 1 - Classical / Detroit Style TDD 2 - Mockist / London Style TDD describe “Benefits of TDD” do context “producing quality software” do it “results in a test suite” do
78. 1 - Classical / Detroit Style TDD 2 - Mockist / London Style TDD describe “Benefits of TDD” do context “producing quality software” do it “results in a test suite” do unit collaborator collaborator
79. 1 - Classical / Detroit Style TDD 2 - Mockist / London Style TDD describe “Benefits of TDD” do context “producing quality software” do it “results in a test suite” do unit collaborator collaborator unit collaborator
80. 1 - Classical / Detroit Style TDD 2 - Mockist / London Style TDD describe “Benefits of TDD” do context “producing quality software” do it “results in a test suite” do unit collaborator collaborator unit collaborator unit
81. describe SayHello do it "returns a greeting using a formatted name" do formatter = double("Name Formatter") allow(formatter).to receive(:format).and_return("JOHN") greeting = SayHello.call("John", formatter: formatter) expect(greeting).to eq("Hello there JOHN!") end end class SayHello def self.call(name, formatter: CapitalizeFormatter.new) capitalized_name = formatter.format(name) end end
82. describe SayHello do it "returns a greeting using a formatted name" do formatter = double("Name Formatter") allow(formatter).to receive(:format).and_return("JOHN") greeting = SayHello.call("John", formatter: formatter) expect(greeting).to eq("Hello there JOHN!") end end class SayHello def self.call(name, formatter: CapitalizeFormatter.new) capitalized_name = formatter.format(name) end end
83. describe SayHello do it "returns a greeting using a formatted name" do formatter = double("Name Formatter") allow(formatter).to receive(:format).and_return("JOHN") greeting = SayHello.call("John", formatter: formatter) expect(greeting).to eq("Hello there JOHN!") end end class SayHello def self.call(name, formatter: CapitalizeFormatter.new) capitalized_name = formatter.format(name) end end
84. describe SayHello do it "returns a greeting using a formatted name" do formatter = double("Name Formatter") allow(formatter).to receive(:format).and_return("JOHN") greeting = SayHello.call("John", formatter: formatter) expect(greeting).to eq("Hello there JOHN!") end end class SayHello def self.call(name, formatter: CapitalizeFormatter.new) capitalized_name = formatter.format(name) end end
85. describe SayHello do it "returns a greeting using a formatted name" do formatter = double("Name Formatter") allow(formatter).to receive(:format).and_return("JOHN") greeting = SayHello.call("John", formatter: formatter) expect(greeting).to eq("Hello there JOHN!") end end class SayHello def self.call(name, formatter:) formatted_name = formatter.format(name) "Hello there #{formatted_name}!" end end
86. 1 - Classical / Detroit Style TDD describe “Benefits of TDD” do context “producing quality software” do it “results in a test suite” do SayHello Mock or Stub 2 - Mockist / London Style TDD
87. 1 - Classical / Detroit Style TDD describe “Benefits of TDD” do context “producing quality software” do it “results in a test suite” do “Solitary” or Isolated Unit Tests SayHello Mock or Stub 2 - Mockist / London Style TDD
88. 1 - Classical / Detroit Style TDD describe “Benefits of TDD” do context “producing quality software” do it “results in a test suite” do 2 - Mockist / London Style TDD use both styles
89. $ rspec --format documentation tdd_benefits_spec.rb:55 Benefits of TDD producing quality software helps when writing tests first produces a test suite Finished in 10 minutes and 0.64148 seconds 2 examples, 0 failures
90. on writing tests
91. generates many tests
92. exploratory E2E / smoke acceptance / component integration unit
93. test as little as possible to give you a certain level of confidence tip #1
94. test as little as possible to give you a certain level of confidence class SayHello def self.call(name, formatter: CapitalizeFormatter.new) formatted_name = formatter.format(name) "Hello there #{formatted_name}!" end end tip #1
95. test as little as possible to give you a certain level of confidence class SayHello def self.call(name, formatter: CapitalizeFormatter.new) formatted_name = formatter.format(name) "Hello there #{formatted_name}!" end end class CapitalizeFormatter def format(name) name.upcase end end tip #1
96. test as little as possible to give you a certain level of confidence tip #1 describe SayHello do it "allows changing the way the name is formatted to be capitalized" do expect( SayHello.call("John", formatter: CapitalizeFormatter.new) ).to eq("Hello there JOHN!") end end
97. test as little as possible to give you a certain level of confidence tip #1 describe SayHello do it "allows changing the way the name is formatted to be capitalized" do expect( SayHello.call("John", formatter: CapitalizeFormatter.new) ).to eq("Hello there JOHN!") end end describe CapitalizeFormatter do it "capitalizes the name" do expect( CapitalizeFormatter.new.format("John") ).to eq("JOHN") end end
98. test as little as possible to give you a certain level of confidence tip #1 describe SayHello do it "allows changing the way the name is formatted to be capitalized" do expect( SayHello.call("John", formatter: CapitalizeFormatter.new) ).to eq("Hello there JOHN!") end end describe CapitalizeFormatter do it "capitalizes the name" do expect( CapitalizeFormatter.new.format("John") ).to eq("JOHN") end end
99. test as little as possible to give you a certain level of confidence tip #1 describe SayHello do it "allows changing the way the name is formatted to be capitalized" do expect( SayHello.call("John", formatter: CapitalizeFormatter.new) ).to eq("Hello there JOHN!") end end
100. always ask why? tip #2
101. tip #2 always ask why? validate the system
102. tip #2 always ask why? validate the system enable safe refactoring
103. tip #2 always ask why? validate the system enable safe refactoring document behaviour
104. tip #2 always ask why? validate the system enable safe refactoring document behaviour get immediate feedback
105. tip #2 always ask why? validate the system enable safe refactoring document behaviour get immediate feedback to know when you’re done
106. tip #2 always ask why?
107. the goal isn’t 100% code coverage tip #3
108. the goal isn’t 100% code coverage tip #3 class SayHello def self.call(name) "Hello there #{name}!" end end
109. the goal isn’t 100% code coverage tip #3 class SayHello def self.call(name) "Hello there #{name}!" end end describe SayHello do it “has 100% code coverage” do SayHello.call("John") end end
110. tests follow a consistent structure tip #4
111. tests follow a consistent structure tip #4 describe SayHello do it "returns a greeting for formatted name" do stub_formatter = double("Stub Name Formatter", format: 'j0hn') result = SayHello.call("John", formatter: stub_formatter) expect(result).to eq("Hello there j0hn!") end end
112. tests follow a consistent structure tip #4 describe SayHello do it "returns a greeting for formatted name" do stub_formatter = double("Stub Name Formatter", format: 'j0hn') result = SayHello.call("John", formatter: stub_formatter) expect(result).to eq("Hello there j0hn!") end end Arrange
113. tests follow a consistent structure tip #4 describe SayHello do it "returns a greeting for formatted name" do stub_formatter = double("Stub Name Formatter", format: 'j0hn') result = SayHello.call("John", formatter: stub_formatter) expect(result).to eq("Hello there j0hn!") end end Arrange Act
114. tests follow a consistent structure tip #4 describe SayHello do it "returns a greeting for formatted name" do stub_formatter = double("Stub Name Formatter", format: 'j0hn') result = SayHello.call("John", formatter: stub_formatter) expect(result).to eq("Hello there j0hn!") end end Arrange Act Assert
115. tests follow a consistent structure tip #4 describe SayHello do it "allows changing the way the name is formatted" do mock_formatter = double("Mock Name Formatter") expect(mock_formatter).to receive(:format).with("John").and_return("JOHN") SayHello.call("John", formatter: mock_formatter) end end
116. tests follow a consistent structure tip #4 describe SayHello do it "allows changing the way the name is formatted" do mock_formatter = double("Mock Name Formatter") expect(mock_formatter).to receive(:format).with("John").and_return("JOHN") SayHello.call("John", formatter: mock_formatter) end end Arrange
117. tests follow a consistent structure tip #4 describe SayHello do it "allows changing the way the name is formatted" do mock_formatter = double("Mock Name Formatter") expect(mock_formatter).to receive(:format).with("John").and_return("JOHN") SayHello.call("John", formatter: mock_formatter) end end Arrange Assert
118. tests follow a consistent structure tip #4 describe SayHello do it "allows changing the way the name is formatted" do mock_formatter = double("Mock Name Formatter") expect(mock_formatter).to receive(:format).with("John").and_return("JOHN") SayHello.call("John", formatter: mock_formatter) end end Arrange Assert Act
119. fix flaky tests ASAP tip #5
120. describe App do describe '.current_username' do it 'is nil by default' do expect(App.current_username).to be_nil end end end fix flaky tests ASAP tip #5 class LoginUser def call(username) App.current_username = username end end class App class << self attr_accessor :current_username end end describe LoginUser do describe '#call' do it 'updates the current username' do username = 'test@example.com' LoginUser.new.call(username) expect(App.current_username).to eq(username) end end end
121. class LoginUser def call(username) App.current_username = username end end describe LoginUser do describe '#call' do it 'updates the current username' do username = 'test@example.com' LoginUser.new.call(username) expect(App.current_username).to eq(username) end end end fix flaky tests ASAP tip #5 class App class << self attr_accessor :current_username end end describe App do describe '.current_username' do it 'is nil by default' do expect(App.current_username).to be_nil end end end 1 2
122. $ rspec spec/ .. Finished in 0.00895 seconds (files took 0.18042 seconds to load) 2 examples, 0 failures fix flaky tests ASAP tip #5
123. class LoginUser def call(username) App.current_username = username end end describe LoginUser do describe '#call' do it 'updates the current username' do username = 'test@example.com' LoginUser.new.call(username) expect(App.current_username).to eq(username) end end end fix flaky tests ASAP tip #5 class App class << self attr_accessor :current_username end end describe App do describe '.current_username' do it 'is nil by default' do expect(App.current_username).to be_nil end end end 2 1
124. $ rspec spec/ .F Failures: 1) App.current_username is nil by default Failure/Error: expect(App.current_username).to be_nil expected: nil got: "test@example.com" # ./tip_fix_flaky_tests_spec.rb:29:in `block (3 levels) in <top (required)>' Finished in 0.02265 seconds (files took 0.10097 seconds to load) 2 examples, 1 failure Failed examples: rspec ./tip_fix_flaky_tests_spec.rb:28 # App.current_username is nil by default fix flaky tests ASAP tip #5
125. class LoginUser def call(username) App.current_username = username end end describe LoginUser do describe '#call' do it 'updates the current username' do username = 'test@example.com' LoginUser.new.call(username) expect(App.current_username).to eq(username) end end end fix flaky tests ASAP tip #5 class App class << self attr_accessor :current_username end end describe App do describe '.current_username' do it 'is nil by default' do expect(App.current_username).to be_nil end end end ? ?
126. keep your tests DAMP tip #6
127. keep your tests DAMP tip #6 Descriptive And Maintainable Procedures vs Don’t Repeat Yourself
128. keep your tests DAMP tip #6 tiny universes single application vs
129. watch out for fragile tests tip #7
130. watch out for fragile tests tip #7 tight coupling between code and test
131. watch out for fragile tests tip #7 tests mirror implementation
132. watch out for fragile tests tip #7 class AddMoneyToAccount def call(account, cents:) amount_in_dollars = Dollars.new(cents / 100) account.balance = account.balance + amount_in_dollars end end
133. watch out for fragile tests tip #7 class AddMoneyToAccount def call(account, cents:) amount_in_dollars = Dollars.new(cents / 100) account.balance = account.balance + amount_in_dollars end end describe AddMoneyToAccount do it "updates the account balance with the specified amount" do account = Account.new(balance: 10) expect(Dollar).to receive(:new).with(5) expect(account).to receive(:balance=).with(15) AddMoneyToAccount.new.call(account, cents: 500) end end
134. watch out for fragile tests tip #7 class AddMoneyToAccount def call(account, cents:) amount_in_dollars = Dollars.new(cents / 100) account.balance = account.balance + amount_in_dollars end end describe AddMoneyToAccount do it "updates the account balance with the specified amount" do account = Account.new(balance: 10) expect(Dollar).to receive(:new).with(5) expect(account).to receive(:balance=).with(15) AddMoneyToAccount.new.call(account, cents: 500) end end
135. watch out for fragile tests tip #7 class AddMoneyToAccount def call(account, cents:) amount_in_dollars = Dollars.new(cents / 100) account.balance = account.balance + amount_in_dollars end end describe AddMoneyToAccount do it "updates the account balance with the specified amount" do account = Account.new(balance: 10) expect(Dollar).to receive(:new).with(5) expect(account).to receive(:balance=).with(15) AddMoneyToAccount.new.call(account, cents: 500) end end
136. watch out for fragile tests tip #7 class AddMoneyToAccount def call(account, cents:) amount_in_dollars = Dollars.new(cents / 100) account.balance = account.balance + amount_in_dollars end end describe AddMoneyToAccount do it "updates the account balance with the specified amount" do account = Account.new(balance: 10) expect(Dollar).to receive(:new).with(5) expect(account).to receive(:balance=).with(15) AddMoneyToAccount.new.call(account, cents: 500) end end
137. watch out for fragile tests tip #7 class AddMoneyToAccount def call(account, cents:) amount_in_dollars = Dollars.new(cents / 100) account.balance = account.balance + amount_in_dollars end end describe AddMoneyToAccount do it "updates the account balance with the specified amount" do account = Account.new(balance: 10) expect(Dollar).to receive(:new).with(5) expect(account).to receive(:balance=).with(15) AddMoneyToAccount.new.call(account, cents: 500) end end
138. watch out for fragile tests tip #7 class AddMoneyToAccount def call(account, cents:) amount_in_dollars = Dollars.from_cents(cents) account.balance = account.balance + amount_in_dollars end end describe AddMoneyToAccount do it "updates the account balance with the specified amount" do account = Account.new(balance: 10) expect(Dollar).to receive(:new).with(5) expect(account).to receive(:balance=).with(15) AddMoneyToAccount.new.call(account, cents: 500) end end
139. watch out for fragile tests tip #7 class AddMoneyToAccount def call(account, cents:) amount_in_dollars = Dollars.from_cents(cents) account.balance = account.balance + amount_in_dollars end end describe AddMoneyToAccount do it "updates the account balance with the specified amount" do account = Account.new(balance: 10) expect(Dollar).to receive(:new).with(5) expect(account).to receive(:balance=).with(15) AddMoneyToAccount.new.call(account, cents: 500) end end
140. watch out for fragile tests tip #7 test behaviour
141. watch out for fragile tests tip #7 class AddMoneyToAccount def call(account, cents:) amount_in_dollars = Dollars.new(cents / 100) account.balance = account.balance + amount_in_dollars end end describe AddMoneyToAccount do it "updates the account balance with the specified amount" do account = Account.new(balance: 10) AddMoneyToAccount.new.call(account, cents: 500) expect(account.balance).to eq(Dollars.new(15)) end end
142. watch out for fragile tests tip #7 class AddMoneyToAccount def call(account, cents:) amount_in_dollars = Dollars.from_cents(cents) account.balance = account.balance + amount_in_dollars end end describe AddMoneyToAccount do it "updates the account balance with the specified amount" do account = Account.new(balance: 10) AddMoneyToAccount.new.call(account, cents: 500) expect(account.balance).to eq(Dollars.new(15)) end end
143. avoid over isolation tip #8
144. describe SayHello do it "returns a greeting using a formatted name" do formatter = double("Name Formatter") allow(formatter).to receive(:format).and_return("JOHN") greeting = SayHello.call("John", formatter: formatter) expect(greeting).to eq("Hello there JOHN!") end end avoid over isolation tip #8
145. class SayHello def self.call(name, formatter: CapitalizeFormatter.new) formatted_name = formatter.format(name) "Hello there #{formatted_name}!" end end avoid over isolation tip #8
146. class SayHello def self.call(name, formatter: CapitalizeFormatter.new) formatted_name = formatter.format(name) "Hello there #{formatted_name}!" end end class CapitalizeFormatter def format(name) name.upcase end end avoid over isolation tip #8
147. class SayHello def self.call(name, formatter: CapitalizeFormatter.new) formatted_name = formatter.format(name) "Hello there #{formatted_name}!" end end class CapitalizeFormatter def pretty_format(name) name.upcase end end avoid over isolation tip #8
148. describe SayHello do it "returns a greeting using a formatted name" do formatter = double("Name Formatter") allow(formatter).to receive(:format).and_return("JOHN") greeting = SayHello.call("John", formatter: formatter) expect(greeting).to eq("Hello there JOHN!") end end avoid over isolation tip #8
149. describe SayHello do it "returns a greeting using a formatted name" do formatter = instance_double("CapitalizeFormatter") allow(formatter).to receive(:format).and_return("JOHN") greeting = SayHello.call("John", formatter: formatter) expect(greeting).to eq("Hello there JOHN!") end end avoid over isolation tip #8 use verifying doubles
150. avoid over isolation tip #8 mix solitary with sociable unit tests
151. only mock what you own tip #9
152. only mock what you own tip #9 class ChargeAccount def call(account, amount, description) # ... Stripe::Charge.create( amount: amount, currency: 'usd', source: account.stripe_customer_id, description: description) # ... end end
153. only mock what you own tip #9 describe ChargeAccount do it "bills the account" do account = Account.new(stripe_customer_id: 'cus_123') expect(Stripe::Charge). to receive(:create). with(amount: 500, currency: 'usd', source: 'cus_123', description: 'test') ChargeAccount.new.call(account, 500, 'test') end end
154. only mock what you own tip #9 describe ChargeAccount do it "bills the account" do account = Account.new(stripe_customer_id: 'cus_123') expect(Stripe::Charge). to receive(:create). with(amount: 500, currency: 'usd', source: 'cus_123', description: 'test') ChargeAccount.new.call(account, 500, 'test') end end
155. only mock what you own tip #9 describe ChargeAccount do it "bills the account" do account = Account.new(stripe_customer_id: 'cus_123') mock_credit_card_gateway = double('Credit Card Gateway') expect(mock_credit_card_gateway). to receive(:charge). with(account: account, amount: 500, description: 'test') ChargeAccount.new(mock_credit_card_gateway). call(account, 500, 'test') end end
156. TDD isn’t a magic bullet tip #10
157. TDD isn’t a magic bullet tip #10 write more tests for critical sections
158. TDD isn’t a magic bullet tip #10 invest in additional testing techniques
159. TDD isn’t a magic bullet tip #10 mutation testing https://github.com/mbj/mutant
160. TDD isn’t a magic bullet tip #10 mutation testing describe ClassifyIP do describe ".call" do it "returns 'even' when the IP is divisible by 2" do stub_ip_service = double('Stub IP Service’, my_ip: ‘192.168.2.2') expect( ClassifyIP.call(ip_service: stub_ip_service) ).to eq('even') end end end
161. TDD isn’t a magic bullet tip #10 mutation testing class ClassifyIP def self.call(ip_service = WhatIsMyIpAddress.new) public_ip = ip_service.my_ip if public_ip.split('.').last.to_i % 2 == 0 'even' else 'odd' end end end
162. TDD isn’t a magic bullet tip #10 mutation testing class ClassifyIP def self.call(ip_service = WhatIsMyIpAddress.new) public_ip = ip_service.my_ip if public_ip.split('.').last.to_i % 2 == 0 'even' else 'odd' end end end
163. TDD isn’t a magic bullet tip #10 mutation testing class ClassifyIP def self.call(ip_service = WhatIsMyIpAddress.new) public_ip = ip_service.my_ip if public_ip.split('.').last.to_i % 2 0 'even' else 'odd' end end end !=
164. TDD isn’t a magic bullet tip #10 property-based testing https://github.com/abargnesi/rantly
165. TDD isn’t a magic bullet tip #10 property-based testing describe ClassifyIP do describe ".call" do it "returns 'even' when the IP is divisible by 2" do property_of { i = integer; integer % 2 == 0 }.check { |i| stub_ip_service = double('Stub IP Service’, my_ip: "192.168.2.#{i}") expect( ClassifyIP.call(ip_service: stub_ip_service) ).to eq(‘even') } end end end
166. TDD isn’t a magic bullet tip #10 property-based testing describe ClassifyIP do describe ".call" do it "returns 'even' when the IP is divisible by 2" do property_of { i = integer; integer % 2 == 0 }.check { |i| stub_ip_service = double('Stub IP Service’, my_ip: "192.168.2.#{i}") expect( ClassifyIP.call(ip_service: stub_ip_service) ).to eq(‘even') } end end end
167. TDD isn’t a magic bullet tip #10 property-based testing describe ClassifyIP do describe ".call" do it "returns 'even' when the IP is divisible by 2" do property_of { i = integer; integer % 2 == 0 }.check { |i| stub_ip_service = double('Stub IP Service’, my_ip: "192.168.2.#{i}") expect( ClassifyIP.call(ip_service: stub_ip_service) ).to eq(‘even') } end end end
168. TDD isn’t a magic bullet tip #10 property-based testing describe ClassifyIP do describe ".call" do it "returns 'even' when the IP is divisible by 2" do property_of { i = integer; integer % 2 == 0 }.check { |i| stub_ip_service = double('Stub IP Service’, my_ip: "192.168.2.#{i}") expect( ClassifyIP.call(ip_service: stub_ip_service) ).to eq(‘even') } end end end
169. TDD isn’t a magic bullet tip #10 consumer-driven contract tests https://docs.pact.io/
170. TDD isn’t a magic bullet tip #10 consumer-driven contract tests client / consumer server / producer test test test test test
171. TDD isn’t a magic bullet tip #10 consumer-driven contract tests test test test test test consumer test expectations of server’s API client / consumer server / producer
172. the value of TDD on writing tests
173. $ rspec --format documentation tdd_benefits_spec.rb Benefits of TDD delivering software faster is a productive workflow lowers maintenance costs facilitates working in teams
174. $ rspec --format documentation tdd_benefits_spec.rb Benefits of TDD delivering software faster is a productive workflow lowers maintenance costs facilitates working in teams adapting to user’s changes helps produce a better design it doesn’t guarantee a good design good design follows S.O.L.I.D. principles follows 4 Rules of Simple Design favours separation of concerns
175. $ rspec --format documentation tdd_benefits_spec.rb Benefits of TDD delivering software faster is a productive workflow lowers maintenance costs facilitates working in teams adapting to user’s changes helps produce a better design it doesn’t guarantee a good design good design follows S.O.L.I.D. principles follows 4 Rules of Simple Design favours separation of concerns producing quality software helps when writing tests first produces a test suite Finished in 2 minutes and 0.64148 seconds 5 examples, 0 failures
176. $ rspec --format documentation tdd_disadvantages_spec.rb Disadvantages of TDD takes time to write the tests doesn’t solve every design problem doesn’t solve every testing and quality problem some things just can’t be TDDed Finished in 1 minutes and 0.64148 seconds 4 examples, 4 failures
177. tip #1 test as little as possible to give you a certain level of confidence tip #2 always ask why? tip #3 the goal isn’t 100% code coverage tip #4 tests follow a consistent structure tip #6 keep your tests DAMP tip #5 fix flaky tests ASAP tip #7 watch out for fragile tests tip #8 avoid over isolation tip #9 only mock what you own tip #10 TDD isn’t a magic bullet on writing tests
178. Raoul Felix Craft of TDD the
179. references bit.ly/the-craft-of-tdd
180. #tdd references bit.ly/the-craft-of-tdd
181. references #tdd questions? bit.ly/the-craft-of-tdd
182. Raoul Felix Craft of TDD the