Writing truly testable code 2.0 - Mobius Spb 2017

Many developers understand why testing is so important, but not everyone is writing tests on a daily basis. One of the most common issues is that it’s hard to test a codebase that was not designed to be testable. This talk will cover how to write code that can be tested easily. We will also talk about introducing testing to an existing not-test-ready codebase. While things like Android, MVP, Kotlin, and Rx will be used in examples, understanding of these technologies is not strictly required. Also, the approach itself is generic enough to be used on any platform or with any language.

Transcript

1. Writing truly testable code Anton Rutkevich Juno
2. Why tests? • Codebase grows -> chances of making a mistake go up • Software gets released -> cost of a mistake goes up -> Fear of introducing modifications!
3. The two major issues • Managing system complexity -> Rich Hickey “Simple Made Easy” • Testing the system -> this talk
4. Our first test
5. Our first test attempt
6. What could possibly go wrong? System under test Network Platform UI Image loading
7. Agenda • Truly testable is ... • 3 rules of truly testable code • Testability in practice • How to start?
8. Truly testable is…
9. What is a test? SUT Inputs PASS Outputs VALIDATE
10. Truly testable is… all inputs and outputs are under control
11. 3 rules of truly testable code
12. Rule #1
13. Testing a function f(Arg[1], … , Arg[N]) -> (R[1], … , R[L])
14. A non-pure function fun nextItemDescription(prefix: String): String { GLOBAL_VARIABLE++ return "$prefix: $GLOBAL_VARIABLE" }
15. A non-pure function Non-pure function Inputs Outputs Inputs Outputs
16. A pure function Pure function Inputs Outputs
17. A pure function fun itemDescription(prefix: String, itemIndex: Int): String { return "$prefix: $itemIndex" } Pure function Inputs Outputs
18. A function is easy to test if Arg[i] and R[i] are explicit: passed through parameters and returned as results f(Arg[1], … , Arg[N]) -> (R[1], … , R[L])
19. Rule #1 Pass arguments & results explicitly
20. Rule #2
21. Testing a module M(In[1], … , In[N]) -> (Out[1], … , Out[L])
22. Testing a module Module Inputs Outputs
23. Module inputs class Module( val title: String, // input ) { }
24. Module inputs class Module( val title: String, // input ) { fun doSomething() { // input // ... } }
25. Module inputs class Module( val title: String, // input val dependency: Explicit // dependency ) { fun doSomething() { // input val explicit = dependency.getCurrentState() // input // ... } }
26. Module inputs class Module( val title: String, // input val dependency: Explicit // dependency ) { fun doSomething() { // input val explicit = dependency.getCurrentState() // input val implicit = Implicit.getCurrentState() // input // ... } }
27. Module inputs class Module( val title: String, // input val dependency: Explicit // dependency ) { fun doSomething() { // input val explicit = dependency.getCurrentState() // input val implicit = Implicit.getCurrentState() // input // ... } }
28. Module outputs class Module( ) { var state = "Some state" fun doSomething() { state = "New state" // output // ... } }
29. Module outputs class Module( val dependency: Explicit // dependency ) { var state = "Some state" fun doSomething() { state = "New state" // output dependency.setCurrentState("New state") // output // ... } }
30. Module outputs class Module( val dependency: Explicit // dependency ) { var state = "Some state" fun doSomething() { state = "New state" // output dependency.setCurrentState("New state") // output Implicit.setCurrentState("New state") // output // ... } }
31. Module outputs class Module( val dependency: Explicit // dependency ) { var state = "Some state" fun doSomething() { state = "New state" // output dependency.setCurrentState("New state") // output Implicit.setCurrentState("New state") // output // ... } }
32. Module inputs • Interactions with module API and dependencies API • Values passed through the interactions • Order of the interactions • Timings between the interactions In[1], … , In[N]
33. Module outputs • Interactions with module API and dependencies API • Values passed through the interactions • Order of the interactions • Timings between the interactions • Modifications of the module state Out[1], … , Out[N]
34. Testing a module Test = call of the function + validation of the outputs M(In[1], … , In[N]) -> (Out[1], … , Out[L]) given, when then
35. A module is easy to test if In[i] and Out[i] are passed through module API or explicit dependencies API. M(In[1], … , In[N]) -> (Out[1], … , Out[L])
36. Rule #2 Pass dependencies explicitly
37. Rule #3
38. Explicit arguments & dependencies == full control ?
39. Explicit dependency test class Module(explicit: Explicit) { val tripled = 3 * explicit.getValue() }
40. Explicit dependency test class Module(explicit: Explicit) { val tripled = 3 * explicit.getValue() } @Test fun testValueGetsTripled() { }
41. Explicit dependency test class Module(explicit: Explicit) { val tripled = 3 * explicit.getValue() } @Test fun testValueGetsTripled() { // prepare Explicit dependency val result = Module( ??? ).tripled }
42. Explicit dependency test class Module(explicit: Explicit) { val tripled = 3 * explicit.getValue() } @Test fun testValueGetsTripled() { // prepare Explicit dependency val result = Module( ??? ).tripled val expected = 15 }
43. Explicit dependency test class Module(explicit: Explicit) { val tripled = 3 * explicit.getValue() } @Test fun testValueGetsTripled() { // prepare Explicit dependency val result = Module( ??? ).tripled val expected = 15 assertThat(result).isEqualTo(expected) }
44. Explicit dependency test class Module(explicit: Explicit) { val tripled = 3 * explicit.getValue() } @Test fun testValueGetsTripled() { // prepare Explicit dependency val result = Module( ??? ).tripled val expected = 15 assertThat(result).isEqualTo(expected) }
45. ‘Explicit’ as a Singleton // ‘object’ stands for Singleton in Kotlin object Explicit { fun getValue(): Int = ... }
46. ‘Explicit’ as a Singleton // ‘object’ stands for Singleton in Kotlin object Explicit { fun getValue(): Int = ... } @Test fun testValueGetsTripled() { val result = Module( ??? ).tripled val expected = 15 assertThat(result).isEqualTo(expected) }
47. ‘Explicit’ as a final class // Classes are final by default in Kotlin class Explicit { fun getValue(): Int = ... }
48. ‘Explicit’ as a final class // Classes are final by default in Kotlin class Explicit { fun getValue(): Int = ... } @Test fun testValueGetsTripled() { val result = Module( ??? ).tripled val expected = 15 assertThat(result).isEqualTo(expected) }
49. ‘Explicit’ as an Interface interface Explicit { fun getValue(): Int class Impl: Explicit { override fun getValue(): Int = ... } }
50. ‘Explicit’ as an Interface @Test fun testValueGetsTripled() { // prepare Explicit dependency val result = Module( ??? ).tripled val expected = 15 assertThat(result).isEqualTo(expected) }
51. ‘Explicit’ as an Interface @Test fun testValueGetsTripled() { val mockedExplicit = object : Explicit { override fun getValue(): Int = 5 } val result = Module(mockedExplicit).tripled val expected = 15 assertThat(result).isEqualTo(expected) }
52. ‘Explicit’ as an Interface @Test fun testValueGetsTripled() { val mockedExplicit = object : Explicit { override fun getValue(): Int = 5 } val result = Module(mockedExplicit).tripled val expected = 15 assertThat(result).isEqualTo(expected) }
53. Rule #3 Make sure you can mock dependencies
54. Testability in practice
55. Platform API 3rd party API Model Presenter UI Framework Platform wrappers View MVP. Overview
56. Platform API 3rd party API Model Presenter UI Framework Platform wrappers View MVP. Overview
57. Practical aspects 1. Understand explicits 2. Locate implicits and convert them to explicits 3. Mock dependencies in tests 4. Abstract away the platform 5. Consider extracting implementation details
58. Testability in practice. Understanding explicits
59. Explicit inputs class ModuleInputs( input: String, ) { }
60. Explicit inputs class ModuleInputs( input: String, inputLambda: () -> String, ) { }
61. Explicit inputs class ModuleInputs( input: String, inputLambda: () -> String, inputObservable: Observable<String>, ) { }
62. Explicit inputs class ModuleInputs( input: String, inputLambda: () -> String, inputObservable: Observable<String>, ) { fun passInput(input: String) { } }
63. Explicit inputs class ModuleInputs( input: String, inputLambda: () -> String, inputObservable: Observable<String>, dependency: Explicit ) { private val someField = dependency.getInput() fun passInput(input: String) { } }
64. Explicit inputs class ModuleInputs( input: String, inputLambda: () -> String, inputObservable: Observable<String>, dependency: Explicit ) { private val someField = dependency.getInput() fun passInput(input: String) { } }
65. Explicit outputs class ModuleOutputs( ) { fun getOutput(): String = "Output" }
66. Explicit outputs class ModuleOutputs( outputLambda: (String) -> Unit, ) { fun getOutput(): String = "Output" init { outputLambda("Output") } }
67. Explicit outputs class ModuleOutputs( outputLambda: (String) -> Unit, ) { val outputObservable = Observable.just("Output") fun getOutput(): String = "Output" init { outputLambda("Output") } }
68. Explicit outputs class ModuleOutputs( outputLambda: (String) -> Unit, dependency: Explicit ) { val outputObservable = Observable.just("Output") fun getOutput(): String = "Output" init { outputLambda("Output") dependency.passOutput("Output") } }
69. Explicit outputs class ModuleOutputs( outputLambda: (String) -> Unit, dependency: Explicit ) { val outputObservable = Observable.just("Output") fun getOutput(): String = "Output" init { outputLambda("Output") dependency.passOutput("Output") } }
70. Testability in practice. Top 5 Implicits
71. #5: Statics and Singletons class Module { private val state = Implicit.getCurrentState() }
72. #5: Statics and Singletons class Module(dependency: Explicit) { private val state = dependency.getCurrentState() }
73. #5: Statics and Singletons class Module(dependency: Explicit) { private val state = dependency.getCurrentState() }
74. #4: Random generators class Module { private val fileName = "some-file${Random().nextInt()}" }
75. #4: Random generators class Module(rng: Rng) { private val fileName = "some-file${rng.nextInt()}" }
76. #4: Random generators class Module(rng: Rng) { private val fileName = "some-file${rng.nextInt()}" }
77. #3: File system & other storage class Module { fun initStorage(path: String) { File(path).createNewFile() } }
78. #3: File system & other storage class Module { fun initStorage(path: String): FileCreationError? { return if (File(path).createNewFile()) { null } else { FileCreationError.Exists } } }
79. #3: File system & other storage class Module { fun initStorage(path: String): FileCreationError? = try { if (File(path).createNewFile()) { null } else { FileCreationError.Exists } } catch (e: SecurityException) { FileCreationError.Security(e) } catch (e: Exception) { FileCreationError.Other(e) } }
80. #3: File system & other storage class Module { fun initStorage(path: String): FileCreationError? = try { if (File(path).createNewFile()) { null } else { FileCreationError.Exists } } catch (e: SecurityException) { FileCreationError.Security(e) } catch (e: Exception) { FileCreationError.Other(e) } }
81. #3: File system & other storage class Module(private val fileCreator: FileCreator) { fun initStorage(path: String): FileCreationError? = try { if (fileCreator.createNewFile(path)) { null } else { FileCreationError.Exists } } catch (e: SecurityException) { FileCreationError.Security(e) } catch (e: Exception) { FileCreationError.Other(e) } }
82. #3: File system & other storage class Module(private val fileCreator: FileCreator) { fun initStorage(path: String): FileCreationError? = try { if (fileCreator.createNewFile(path)) { null } else { FileCreationError.Exists } } catch (e: SecurityException) { FileCreationError.Security(e) } catch (e: Exception) { FileCreationError.Other(e) } }
83. #2: Time class Module { private val nowTime = System.currentTimeMillis() private val nowDate = Date() // and all other time/date APIs }
84. #2: Time class Module(time: TimeProvider) { private val nowTime = time.nowMillis() private val nowDate = time.nowDate() // and all other time/date APIs }
85. #2: Time class Module(time: TimeProvider) { private val nowTime = time.nowMillis() private val nowDate = time.nowDate() // and all other time/date APIs }
86. #1: Formatting & Locales class MyTimePresenter(timestamp: Long) { val formattedTimestamp = SimpleDateFormat("yyyy-MM-dd HH:mm") .format(timestamp) }
87. #1: Formatting & Locales class MyTimePresenter(timestamp: Long) { val formattedTimestamp = SimpleDateFormat("yyyy-MM-dd HH:mm") .format(timestamp) } fun test() { }
88. #1: Formatting & Locales class MyTimePresenter(timestamp: Long) { val formattedTimestamp = SimpleDateFormat("yyyy-MM-dd HH:mm") .format(timestamp) } fun test() { val mobiusConfStart = 1492758000L }
89. #1: Formatting & Locales class MyTimePresenter(timestamp: Long) { val formattedTimestamp = SimpleDateFormat("yyyy-MM-dd HH:mm") .format(timestamp) } fun test() { val mobiusConfStart = 1492758000L val expected = "" val actual = MyTimePresenter(timestamp).formattedTimestamp assertThat(actual).isEqualTo(expected) }
90. #1: Formatting & Locales class MyTimePresenter(timestamp: Long) { val formattedTimestamp = SimpleDateFormat("yyyy-MM-dd HH:mm") .format(timestamp) } fun test() { val mobiusConfStart = 1492758000L val expected = "2017-04-21 10:00" val actual = MyTimePresenter(timestamp).formattedTimestamp assertThat(actual).isEqualTo(expected) }
91. #1: Formatting & Locales class MyTimePresenter(timestamp: Long) { val formattedTimestamp = SimpleDateFormat("yyyy-MM-dd HH:mm") .format(timestamp) } fun test() { val mobiusConfStart = 1492758000L val expected = "2017-04-21 10:00" val actual = MyTimePresenter(timestamp).formattedTimestamp assertThat(actual).isEqualTo(expected) } >> `actual on dev machine` = "2017-04-21 10:00"
92. #1: Formatting & Locales class MyTimePresenter(timestamp: Long) { val formattedTimestamp = SimpleDateFormat("yyyy-MM-dd HH:mm") .format(timestamp) } fun test() { val mobiusConfStart = 1492758000L val expected = "2017-04-21 10:00" val actual = MyTimePresenter(timestamp).formattedTimestamp assertThat(actual).isEqualTo(expected) } >> `actual on dev machine` = "2017-04-21 10:00" >> `actual on CI` = "2017-04-21 07:00"
93. #1: Formatting & Locales class MyTimePresenter(timestamp: Long) { val formattedTimestamp = SimpleDateFormat("yyyy-MM-dd HH:mm") .format(timestamp) } fun test() { val mobiusConfStart = 1492758000L val expected = "2017-04-21 10:00" val actual = MyTimePresenter(timestamp).formattedTimestamp assertThat(actual).isEqualTo(expected) } >> `actual on dev machine` = "2017-04-21 10:00" // UTC +3 >> `actual on CI` = "2017-04-21 07:00" // UTC
94. #1: Formatting & Locales class MyTimePresenter(timestamp: Long) { val formattedTimestamp = SimpleDateFormat("yyyy-MM-dd HH:mm") .format(timestamp) } fun test() { val mobiusConfStart = 1492758000L val expected = "2017-04-21 10:00" val actual = MyTimePresenter(timestamp).formattedTimestamp assertThat(actual).isEqualTo(expected) } >> `actual on dev machine` = "2017-04-21 10:00" // UTC +3 >> `actual on CI` = "2017-04-21 07:00" // UTC
95. #1: Formatting & Locales Same for 1. NumberFormat 2. Currency 3. Locale 4. TimeZone 5. ...
96. Testability in practice. Mocking
97. Interfaces still work everywhere interface MyService { fun doSomething() class Impl(): MyService { override fun doSomething() { /* ... */ } } }
98. Interfaces still work everywhere interface MyService { fun doSomething() class Impl(): MyService { override fun doSomething() { /* ... */ } } } class TestService: MyService { override fun doSomething() { /* ... */ } }
99. Interfaces still work everywhere interface MyService { fun doSomething() class Impl(): MyService { override fun doSomething() { /* ... */ } } } class TestService: MyService { override fun doSomething() { /* ... */ } } val mockService = mock<MyService>()
100. Interfaces still work everywhere interface MyService { fun doSomething() class Impl(): MyService { override fun doSomething() { /* ... */ } } } class TestService: MyService { override fun doSomething() { /* ... */ } } val mockService = mock<MyService>()
101. Extracting singletons object Implicit { fun getCurrentState(): String = "State" } class SomeModule { init { val state = Implicit.getCurrentState() } }
102. Extracting singletons interface StateProvider { fun getCurrentState(): String } object Implicit { fun getCurrentState(): String = "State" } class SomeModule { init { val state = Implicit.getCurrentState() } }
103. Extracting singletons interface StateProvider { fun getCurrentState(): String } object Implicit: StateProvider { override fun getCurrentState(): String = "State" } class SomeModule { init { val state = Implicit.getCurrentState() } }
104. Extracting singletons interface StateProvider { fun getCurrentState(): String } object Implicit: StateProvider { override fun getCurrentState(): String = "State" } class SomeModule(stateProvider: StateProvider) { init { val state = stateProvider.getCurrentState() } }
105. Extracting singletons interface StateProvider { fun getCurrentState(): String } object Implicit: StateProvider { override fun getCurrentState(): String = "State" } class SomeModule(stateProvider: StateProvider) { init { val state = stateProvider.getCurrentState() } }
106. Mockito 2 for mocking final PowerMock for mocking final, static, singletons, … Other alternatives • Indicate design issues; can be avoided • Might blow up at some point
107. Testability in practice. Abstracting away the platform
108. Platform API 3rd party API Model Presenter UI Framework Platform wrappers View MVP. View layer
109. Presenter isolation
110. View layer approaches • Activity implements View • View as a separate class
111. Activity implements View class SplashPresenter(view: SplashView) { init { view.showLoading() } }
112. Activity implements View interface SplashView { fun showLoading() }
113. Activity implements View interface SplashView { fun showLoading() } class SplashActivity: Activity { override fun onCreate() { } }
114. Activity implements View interface SplashView { fun showLoading() } class SplashActivity: Activity, SplashView { override fun onCreate() { } override fun showLoading() { findViewById(R.id.progress).show() } }
115. Activity implements View interface SplashView { fun showLoading() } class SplashActivity: Activity, SplashView { override fun onCreate() { SplashPresenter(view = this) } override fun showLoading() { findViewById(R.id.progress).show() } }
116. Activity implements View interface SplashView { fun showLoading() } class SplashActivity: Activity, SplashView { override fun onCreate() { SplashPresenter(view = this) } override fun showLoading() { findViewById(R.id.progress).show() } }
117. View as a separate class // Same as before class SplashPresenter(view: SplashView) { init { view.showLoading() } }
118. View as a separate class interface SplashView { fun showLoading() }
119. View as a separate class interface SplashView { fun showLoading() class Impl : SplashView { override fun showLoading() { } } }
120. View as a separate class interface SplashView { fun showLoading() class Impl(private val viewRoot: View) : SplashView { override fun showLoading() { viewRoot.findViewById(R.id.progress).show() } } }
121. View as a separate class interface SplashView { fun showLoading() // Platform lives inside of Impl class Impl(private val viewRoot: View) : SplashView { override fun showLoading() { viewRoot.findViewById(R.id.progress).show() } } }
122. View as a separate class class SplashActivity: Activity { override fun onCreate() { } }
123. View as a separate class class SplashActivity: Activity { override fun onCreate() { // Platform View class val rootView: View = … } }
124. View as a separate class class SplashActivity: Activity { override fun onCreate() { // Platform View class val rootView: View = … SplashPresenter( view = SplashView.Impl(rootView) ) } }
125. View as a separate class class SplashActivity: Activity { override fun onCreate() { // Platform View class val rootView: View = … SplashPresenter( view = SplashView.Impl(rootView) ) } }
126. Presenter is isolated from the platform @Test fun testLoadingIsShown() { val mockedView = mock<SplashView>() }
127. Presenter is isolated from the platform @Test fun testLoadingIsShown() { val mockedView = mock<SplashView>() SplashPresenter(mockedView) }
128. Presenter is isolated from the platform @Test fun testLoadingIsShown() { val mockedView = mock<SplashView>() SplashPresenter(mockedView) verify(mockedView).showLoading() }
129. Presenter is isolated from the platform @Test fun testLoadingIsShown() { val mockedView = mock<SplashView>() SplashPresenter(mockedView) verify(mockedView).showLoading() }
130. Platform API 3rd party API Model Presenter UI Framework Platform wrappers View MVP. Platform wrappers
131. Model isolation
132. You can not modify • Platform APIs • 3rd party APIs
133. They can exist in different forms • Static methods • Singletons • Final classes • Non-final classes
134. They can exist in different forms • Static methods • Singletons • Final classes • Non-final classes
135. They can exist in different forms • Static methods • Singletons • Final classes • Non-final classes
136. They can exist in different forms • Static methods • Singletons • Final classes • Non-final classes
137. They can exist in different forms • Static methods • Singletons • Final classes • Non-final classes
138. Creating a wrapper class Module { init { ThirdParty.doSomething() } }
139. Creating a wrapper interface Wrapper { fun doSomething() class Impl: Wrapper { override fun doSomething() { ThirdParty.doSomething() } } }
140. Applying the wrapper class Module { init { ThirdParty.doSomething() } }
141. Applying the wrapper class Module(wrapper: Wrapper) { init { wrapper.doSomething() } }
142. Applying the wrapper class Module(wrapper: Wrapper) { init { wrapper.doSomething() } }
143. Wrapper extra benefits • Fixes poor Platform API design • Single Responsibility instead of God objects • Easy to apply 3rd party API changes
144. Platform API 3rd party API Model Presenter UI Framework Platform wrappers View MVP. Platform wrappers vs View
145. Accessing resources
146. Accessing string ids class SplashPresenter(view: SplashView, resources: Resources) { init { view.setTitle(resources.getString(R.string.welcome)) view.showLoading() } }
147. Accessing string ids class SplashPresenter(view: SplashView, resources: Resources) { init { view.setTitle(resources.getString(R.string.welcome)) view.showLoading() } } interface Resources { fun getString(id: Int): String }
148. Accessing string ids class SplashPresenter(view: SplashView, resources: Resources) { init { view.setTitle(resources.getString(R.string.welcome)) view.showLoading() } }
149. Accessing string ids public final class R { public static final class string { public static final int welcome=0x7f050000; } }
150. Implementation details
151. Implementation details class SomeModule(input: String) { val state = calculateInitialState(input) // Pure private fun calculateInitialState(input: String): String = "Some complex computation for $input" }
152. Implementation details class SomeModule(input: String) { val state = calculateInitialState(input) // Pure private fun calculateInitialState(input: String): String = "Some complex computation for $input" }
153. Implementation details class SomeModule(input: String) { val state = calculateInitialState(input) // Pure private fun calculateInitialState(input: String): String = "Some complex computation for $input" } class AnotherModule(input: String) { val state = calculateInitialState(input) // Pure private fun calculateInitialState(input: String): String = "Some complex computation for $input" }
154. Implementation details class SomeModule(input: String) { val state = calculateInitialState(input) // Pure private fun calculateInitialState(input: String): String = "Some complex computation for $input" } object StateCalculator { fun calculateInitialState(input: String): String = "Some complex computation for $input" }
155. Implementation details class SomeModule(input: String) { val state = StateCalculator.calculateInitialState(input) } class AnotherModule(input: String) { val state = StateCalculator.calculateInitialState(input) } object StateCalculator { fun calculateInitialState(input: String): String = "Some complex computation for $input" }
156. Implementation details class SomeModule(input: String, stateCalculator: StateCalculator){ val state = stateCalculator.calculateInitialState(input) } interface StateCalculator { fun calculateInitialState(input: String): String class Impl: StateCalculator { override fun calculateInitialState(input: String): String = "Some complex computation for $input" } }
157. How to start?
158. Start with Models Wrapper Model Model Model Model Model
159. Start with Models
160. As a result • Implicit dependencies (singletons) become explicit (passed through DI) • Initialization flow gets explicit • Models become easy to test
161. And then Activity Dependency Graph View Presenter
162. What’s next?
163. Platform API 3rd party API Model Presenter UI Framework Platform wrappers View MVP. Integration tests
164. Platform API 3rd party API Model Presenter UI Framework Platform wrappers View MVP. Integration tests
165. Model Presenter Platform wrappers View MVP. Integration tests
166. To summarize
167. 3 rules • Pass arguments and return results explicitly • Pass dependencies explicitly • Make sure you can mock dependencies
168. Learning the art of programming, like most other disciplines, consists of first learning the rules and then learning when to break them. Joshua Bloch, Effective Java
169. Questions? Twitter, GitHub, Facebook AntonRutkevich e-mail anton@rutkevich.com