Deep Dive into Unit Testing

Testing our code is essential for development process. Yet, creating clean and readable tests is not a piece of cake. During the talk we'll dive into unit testing concepts and see how Kotlin helps us write efficient test code. We will study examples of testing patterns tailored to common application components. We'll discuss Kotlin testing tools that can bring joy and happiness to everyday work.

Transcript

1. DEEP DIVE INTO UNIT TESTING Jarosław Michalik 1
2. JAROSŁAW MICHALIK Android Developer https://twitter.com/rozkminia https://medium.com/@rozkminiacz https://github.com/rozkminiacz/ https://michalik.tech 2
3. TEST STRUCTURE @Test fun `it should return empty string`() { //preconditions val useCase = UseCase() //execution val actual = useCase.execute() //assertion val expected = "" assertEquals(expected, actual) } 3
4. TEST STRUCTURE @Test fun `it should return empty string`() { //given val useCase = UseCase() //when val actual = useCase.execute() //then val expected = "" assertEquals(expected, actual) } 4
5. WHAT MAKES TEST UNIT? 5
6. WHAT MAKES TEST UNIT? 5
7. • Verification of single piece of logic WHAT MAKES TEST UNIT? 5
8. • Verification of single piece of logic • Isolation WHAT MAKES TEST UNIT? 5
9. • Verification of single piece of logic • Isolation • Deterministic behavior WHAT MAKES TEST UNIT? 5
10. TEST EXECUTION FLOW 6
11. TESTS WITH JUNIT4 class DistanceConverterTest { @org.junit.Test fun `it should pass`() { // do nothing } @org.junit.Test fun `it should fail`() { throw java.lang.AssertionError(„failed”) } @org.junit.Test fun `it should fail miserably`() { throw RuntimeException() } } 7
12. TESTS WITH JUNIT4 8
13. TESTS WITH JUNIT4 8
14. JUNIT4 VS JUNIT5 ASSERTIONS class DistanceConverterTest { @Test fun `it should fail - junit5`() { org.junit.jupiter.api.Assertions.assertTrue(false) } @Test fun `it should fail - junit4`() { org.junit.Assert.assertTrue(false) } } 9
15. JUNIT4 VS JUNIT5 ASSERTIONS 10
16. JUNIT4 VS JUNIT5 ASSERTIONS 10
17. BOTH ARE THROWING ASSERTION ERRORS: class DistanceConverterTest { @Test fun `it should fail - junit5`() { org.junit.jupiter.api.Assertions.assertTrue(false) // under the hood: // org.opentest4j.AssertionFailedError(message, expected, actual, cause) } @Test fun `it should fail - junit4`() { org.junit.Assert.assertTrue(false) // under the hood: // throw new java.lang.AssertionError(message); } } 11
18. WHAT IF WE HAVE TWO ASSERTIONS IN TEST CASE? class DistanceConverterTest { @Test fun `two assertion fails`() { assertTrue(false) assertFalse(true) } @Test fun `first assertion fails, second assertion passes`(){ assertTrue(false) assertFalse(false) } } 12
19. WHAT IF WE HAVE TWO ASSERTIONS IN TEST CASE? 13
20. WHAT IF WE HAVE TWO ASSERTIONS IN TEST CASE? 13
21. ASSERTIONS ON EXCEPTIONS 14 class UseCaseThrowingException { fun execute() { throw IOException("Terrible thing happened!") } } @Test(expected = IOException::class) fun `it should throw exception`() { val useCase = UseCaseThrowingException() useCase.execute() }
22. ASSERTIONS ON EXCEPTIONS 15 class UseCaseThrowingException { fun execute() { throw IOException("Terrible thing happened!") } } @Test fun `it should throw exception`() { val useCase = UseCaseThrowingException() assertThrows<IOException> { useCase.execute() } }
23. ASSERTIONS ON EXCEPTIONS 16 class UseCaseThrowingException { fun execute() { throw IOException("Terrible thing happened!") } } @Test fun `it should throw exception`() { val useCase = UseCaseThrowingException() assertThrows<IOException>("Terrible thing happened!") { useCase.execute() } }
24. SIMPLE ASSERTIONS ON EXCEPTIONS @InlineOnly @SinceKotlin("1.3") public inline fun <T, R> T.runCatching(block: T.() -> R): Result<R> { return try { Result.success(block()) } catch (e: Throwable) { Result.failure(e) } } 17
25. SIMPLE ASSERTIONS ON EXCEPTIONS 18 class UseCaseThrowingException { fun execute() { throw IOException("Terrible thing happened!") } } @Test fun `it should throw exception`() { val useCase = UseCaseThrowingException() val exception = runCatching { useCase.execute() } .exceptionOrNull() assertTrue(exception is IOException) }
26. SIMPLE ASSERTIONS ON EXCEPTIONS 19 @Test fun `it should throw exception`() { val useCase = UseCaseThrowingException() val exception = runCatching { useCase.execute() } .exceptionOrNull() assertTrue(exception is IOException) } @Test fun `it should not throw any exception`(){ val useCase = UseCaseThrowingException() val exception = runCatching { useCase.execute() } .exceptionOrNull() assertTrue(exception == null) }
27. class UseCaseTest { @Test fun `it should return empty string`() { val useCase = UseCase() val actual = useCase.execute() val expected = "" assertEquals(expected, actual) } } ASSERTIONS 20
28. class UseCaseTest { @Test fun `it should return empty string`() { val useCase = UseCase() val actual = useCase.execute() val expected = "" assertEquals(expected, actual) } } • Does my unit converter produces expected output? ASSERTIONS 20
29. class UseCaseTest { @Test fun `it should return empty string`() { val useCase = UseCase() val actual = useCase.execute() val expected = "" assertEquals(expected, actual) } } • Does my unit converter produces expected output? • Does my Json mapper converts Json to proper objects? ASSERTIONS 20
30. class UseCaseTest { @Test fun `it should return empty string`() { val useCase = UseCase() val actual = useCase.execute() val expected = "" expectThat(expected).isEqualTo(actual) } } • Built in methods in junit4 and junit5 • Built in methods in KotlinTest • Truth • Strikt ASSERTION TOOLS 21
31. PARAMETERIZED TESTS 22
32. PARAMETERIZED TESTS • Does my unit converter produces expected output for various arguments? typealias Meter = Long typealias Kilometer = Double class DistanceConverter { fun parse(distance: Meter): Kilometer { return when { distance in 0..999 -> distance.div(1000.0) distance in 1000..10_000 -> distance.div(1000.0) distance > 10_000 -> distance.div(1000.0) else -> throw UnsupportedOperationException() } } } 23
33. @RunWith(Parameterized::class) class DistanceConverterTest(val input: Input){ companion object { @JvmStatic @Parameterized.Parameters fun data(): Collection<Input> { return listOf( Input(500, 0.5), Input(750, 0.8) ) } } @Test fun `check distance parser`(){ val converter = DistanceConverter() val actual = converter.parse(input.parameter) val expected = input.expected assertEquals(actual, expected, 0.0) } data class Input(val parameter: Meter, val expected: Kilometer) } 24
34. @RunWith(Parameterized::class) class DistanceConverterTest(val input: Input){ companion object { @JvmStatic @Parameterized.Parameters fun data(): Collection<Input> { return listOf( Input(500, 0.5), Input(750, 0.8) ) } } @Test fun `check distance parser`(){ val converter = DistanceConverter() val actual = converter.parse(input.parameter) val expected = input.expected assertEquals(actual, expected, 0.0) } data class Input(val parameter: Meter, val expected: Kilometer) } parameterized runner 24
35. @RunWith(Parameterized::class) class DistanceConverterTest(val input: Input){ companion object { @JvmStatic @Parameterized.Parameters fun data(): Collection<Input> { return listOf( Input(500, 0.5), Input(750, 0.8) ) } } @Test fun `check distance parser`(){ val converter = DistanceConverter() val actual = converter.parse(input.parameter) val expected = input.expected assertEquals(actual, expected, 0.0) } data class Input(val parameter: Meter, val expected: Kilometer) } parameterized runner 24
36. @RunWith(Parameterized::class) class DistanceConverterTest(val input: Input){ companion object { @JvmStatic @Parameterized.Parameters fun data(): Collection<Input> { return listOf( Input(500, 0.5), Input(750, 0.8) ) } } @Test fun `check distance parser`(){ val converter = DistanceConverter() val actual = converter.parse(input.parameter) val expected = input.expected assertEquals(actual, expected, 0.0) } data class Input(val parameter: Meter, val expected: Kilometer) } parameterized runner static argument provider 24
37. @RunWith(Parameterized::class) class DistanceConverterTest(val input: Input){ companion object { @JvmStatic @Parameterized.Parameters fun data(): Collection<Input> { return listOf( Input(500, 0.5), Input(750, 0.8) ) } } @Test fun `check distance parser`(){ val converter = DistanceConverter() val actual = converter.parse(input.parameter) val expected = input.expected assertEquals(actual, expected, 0.0) } data class Input(val parameter: Meter, val expected: Kilometer) } parameterized runner static argument provider 24
40. class DistanceConverterTest { @ParameterizedTest @ArgumentsSource(TestInputProvider::class) fun `check distance parser`(input: Input) { val converter = DistanceConverter() val actual = converter.parse(input.parameter) val expected = input.expected assertEquals(actual, expected) } class TestInputProvider : ArgumentsProvider { override fun provideArguments( context: ExtensionContext? ): Stream<out Arguments> { return Stream.of( Input(500, 0.5), Input(750, 0.8) ).map { Arguments.of(it) } } } } 26
41. class DistanceConverterTest { @ParameterizedTest @ArgumentsSource(TestInputProvider::class) fun `check distance parser`(input: Input) { val converter = DistanceConverter() val actual = converter.parse(input.parameter) val expected = input.expected assertEquals(actual, expected) } class TestInputProvider : ArgumentsProvider { override fun provideArguments( context: ExtensionContext? ): Stream<out Arguments> { return Stream.of( Input(500, 0.5), Input(750, 0.8) ).map { Arguments.of(it) } } } } parameterized test method 26
42. class DistanceConverterTest { @ParameterizedTest @ArgumentsSource(TestInputProvider::class) fun `check distance parser`(input: Input) { val converter = DistanceConverter() val actual = converter.parse(input.parameter) val expected = input.expected assertEquals(actual, expected) } class TestInputProvider : ArgumentsProvider { override fun provideArguments( context: ExtensionContext? ): Stream<out Arguments> { return Stream.of( Input(500, 0.5), Input(750, 0.8) ).map { Arguments.of(it) } } } } parameterized test method 26
43. class DistanceConverterTest { @ParameterizedTest @ArgumentsSource(TestInputProvider::class) fun `check distance parser`(input: Input) { val converter = DistanceConverter() val actual = converter.parse(input.parameter) val expected = input.expected assertEquals(actual, expected) } class TestInputProvider : ArgumentsProvider { override fun provideArguments( context: ExtensionContext? ): Stream<out Arguments> { return Stream.of( Input(500, 0.5), Input(750, 0.8) ).map { Arguments.of(it) } } } } parameterized test method ArgumentsProvider class 26
44. class DistanceConverterTest { @ParameterizedTest @ArgumentsSource(TestInputProvider::class) fun `check distance parser`(input: Input) { val converter = DistanceConverter() val actual = converter.parse(input.parameter) val expected = input.expected assertEquals(actual, expected) } class TestInputProvider : ArgumentsProvider { override fun provideArguments( context: ExtensionContext? ): Stream<out Arguments> { return Stream.of( Input(500, 0.5), Input(750, 0.8) ).map { Arguments.of(it) } } } } parameterized test method ArgumentsProvider class 26
47. class DistanceConverterTest : StringSpec({ val converter = DistanceConverter() „Convert meter to kilometer" { val inputs = listOf( Input(500L, 0.5), Input(750L, 0.8) ) inputs.forAll { (meter, kilometer) -> meter.toKilometer() shouldBe kilometer } } }) 28
48. class DistanceConverterTest : StringSpec({ val converter = DistanceConverter() „Convert meter to kilometer" { val inputs = listOf( Input(500L, 0.5), Input(750L, 0.8) ) inputs.forAll { (meter, kilometer) -> meter.toKilometer() shouldBe kilometer } } }) lambda with test source 28
49. class DistanceConverterTest : StringSpec({ val converter = DistanceConverter() „Convert meter to kilometer" { val inputs = listOf( Input(500L, 0.5), Input(750L, 0.8) ) inputs.forAll { (meter, kilometer) -> meter.toKilometer() shouldBe kilometer } } }) lambda with test source 28
50. class DistanceConverterTest : StringSpec({ val converter = DistanceConverter() „Convert meter to kilometer" { val inputs = listOf( Input(500L, 0.5), Input(750L, 0.8) ) inputs.forAll { (meter, kilometer) -> meter.toKilometer() shouldBe kilometer } } }) lambda with test source easy collection testing 28
51. class DistanceConverterTest : StringSpec({ val converter = DistanceConverter() „Convert meter to kilometer" { val inputs = listOf( Input(500L, 0.5), Input(750L, 0.8) ) inputs.forAll { (meter, kilometer) -> meter.toKilometer() shouldBe kilometer } } }) lambda with test source easy collection testing 28
54. 29 java.lang.AssertionError: 1 elements passed but expected 4 The following elements passed: Input(meter=500, kilometer=0.5) The following elements failed: Input(meter=750, kilometer=0.8) => expected: 0.8 but was: 0.75 Input(meter=730, kilometer=0.8) => expected: 0.8 but was: 0.73 Input(meter=710, kilometer=0.8) => expected: 0.8 but was: 0.71
55. class DistanceParserParametrizedTest : Spek({ describe("distance parser") { val converter = DistanceConverter() listOf(Input(500, 0.5),Input(750, 0.8)) .forEach { (param, expected) -> it("should parse ${param}m to ${expected}km") { assertEquals(expected, param.toKilometers()) } } } }) 30
56. class DistanceParserParametrizedTest : Spek({ describe("distance parser") { val converter = DistanceConverter() listOf(Input(500, 0.5),Input(750, 0.8)) .forEach { (param, expected) -> it("should parse ${param}m to ${expected}km") { assertEquals(expected, param.toKilometers()) } } } }) lambda with test source 30
57. class DistanceParserParametrizedTest : Spek({ describe("distance parser") { val converter = DistanceConverter() listOf(Input(500, 0.5),Input(750, 0.8)) .forEach { (param, expected) -> it("should parse ${param}m to ${expected}km") { assertEquals(expected, param.toKilometers()) } } } }) lambda with test source 30
58. class DistanceParserParametrizedTest : Spek({ describe("distance parser") { val converter = DistanceConverter() listOf(Input(500, 0.5),Input(750, 0.8)) .forEach { (param, expected) -> it("should parse ${param}m to ${expected}km") { assertEquals(expected, param.toKilometers()) } } } }) lambda with test source easy test grouping and nesting 30
59. class DistanceParserParametrizedTest : Spek({ describe("distance parser") { val converter = DistanceConverter() listOf(Input(500, 0.5),Input(750, 0.8)) .forEach { (param, expected) -> it("should parse ${param}m to ${expected}km") { assertEquals(expected, param.toKilometers()) } } } }) lambda with test source easy test grouping and nesting 30
60. class DistanceParserParametrizedTest : Spek({ describe("distance parser") { val converter = DistanceConverter() listOf(Input(500, 0.5),Input(750, 0.8)) .forEach { (param, expected) -> it("should parse ${param}m to ${expected}km") { assertEquals(expected, param.toKilometers()) } } } }) lambda with test source easy test grouping and nesting test functions are extension functions 30
61. class DistanceParserParametrizedTest : Spek({ describe("distance parser") { val converter = DistanceConverter() listOf(Input(500, 0.5),Input(750, 0.8)) .forEach { (param, expected) -> it("should parse ${param}m to ${expected}km") { assertEquals(expected, param.toKilometers()) } } } }) lambda with test source easy test grouping and nesting test functions are extension functions 30
62. 31 it("should parse ${param}m to ${expected}km") { assertEquals(expected, param.toKilometers()) }
63. 31 it("should parse ${param}m to ${expected}km") { assertEquals(expected, param.toKilometers()) }
64. BEST PRACTICES IN PARAMETERIZED TESTS 32
65. BEST PRACTICES IN PARAMETERIZED TESTS 32
66. BEST PRACTICES IN PARAMETERIZED TESTS 32
67. • Check just enough test cases BEST PRACTICES IN PARAMETERIZED TESTS 32
68. • Check just enough test cases • Have single test cases described well BEST PRACTICES IN PARAMETERIZED TESTS 32
69. • Check just enough test cases • Have single test cases described well • Make use of type safety (Input class) BEST PRACTICES IN PARAMETERIZED TESTS 32
70. • Check just enough test cases • Have single test cases described well • Make use of type safety (Input class) • Don’t repeat yourself - write extensions for common cases BEST PRACTICES IN PARAMETERIZED TESTS 32
71. TESTING SIDE EFFECTS 33
72. TESTING SIDE EFFECTS 33
73. TESTING SIDE EFFECTS 33
74. • We usually shouldn’t test loggers… TESTING SIDE EFFECTS 33
75. • We usually shouldn’t test loggers… • Non-fatal errors logging for Crashlytics TESTING SIDE EFFECTS 33
76. • We usually shouldn’t test loggers… • Non-fatal errors logging for Crashlytics • Existing solution: custom Timber.Tree TESTING SIDE EFFECTS 33
77. TESTING SIDE EFFECTS class CrashlyticsTree : Timber.Tree() { override fun log(priority: Int, tag: String?, message: String, throwable: Throwable?) { if (priority == Log.VERBOSE || priority == Log.DEBUG) { return } Crashlytics.log(priority, tag, message) if (throwable != null) { Crashlytics.logException(throwable) } } } 34
78. TESTING SIDE EFFECTS class NonFatalError(message: String) : Exception(message) inline fun logNonFatal(m: String) = Timber.e(NonFatalError(m)) 35
79. TESTING SIDE EFFECTS class SideEffects(){ init { logNonFatal("should not be in this state") } } @Test fun `on fail it should add log`(){ val logs = mutableListOf<String>() Timber.plant(object : Timber.Tree() { override fun log(priority: Int, tag: String?, message: String, t: Throwable?) { logs.add(message) } }) SideEffects() // assertion on logs } 36
80. TESTING SIDE EFFECTS fun withLoggingContext(testBlock: (FakeTimberTree) -> Unit) { val timberTree = FakeTimberTree() Timber.plant(timberTree) testBlock(timberTree) Timber.uprootAll() } class FakeTimberTree : Timber.Tree() { val listOfLogs = mutableListOf<Log>() override fun log(priority: Int, tag: String?, message: String, t: Throwable?) { listOfLogs.add(Log(priority, tag, message, t)) } } 37
81. TESTING SIDE EFFECTS @Test fun `on fail it should log non-fatal`() { withLoggingContext { val sideEffects = SideEffects() expectThat(it.listOfLogs.first().message) .isEqualTo("should not be in this state") } } 38
82. TESTING SIDE EFFECTS 39
83. TESTING SIDE EFFECTS • Do not introduce side effects! 39
84. TESTING SIDE EFFECTS • Do not introduce side effects! • If you have to (legacy code, hacking external library, etc.) give them some nice abstraction 39
85. TEST DOUBLES 40
86. TEST DOUBLES 40
87. • We create test doubles to keep test in isolation TEST DOUBLES 40
88. • We create test doubles to keep test in isolation • They simulate other parts of system TEST DOUBLES 40
89. • We create test doubles to keep test in isolation • They simulate other parts of system • Dependency inversions principle! TEST DOUBLES 40
90. • We create test doubles to keep test in isolation • They simulate other parts of system • Dependency inversions principle! • Mock, Stub, Fake, etc. TEST DOUBLES 40
91. TEST DOUBLES 41
92. TEST DOUBLES • Fake - lightweight implementation 41
93. TEST DOUBLES • Fake - lightweight implementation • Stub - returns some predefined value 41
94. TEST DOUBLES • Fake - lightweight implementation • Stub - returns some predefined value • Mock - to check function invocations 41
95. TEST DOUBLES • Fake - lightweight implementation • Stub - returns some predefined value • Mock - to check function invocations • We often call all test doubles mocks 41
96. EXAMPLE class VenueViewModel(val dataProvider: DataProvider<String, VenueDto>) : ViewModel() { var venues: List<VenueDto> = emptyList() fun start() { dataProvider.getAll().let { venues = it } } } 42
97. EXAMPLE @Test fun `given non-empty dataset when start then load list`() { val givenDtoList = listOf( VenueDto(id = "1", content = "Some data") ) val venueViewModel = VenueViewModel( dataProvider = object : DataProvider<String, VenueDto> { override fun getById(id: String): VenueDto { TODO("not implemented") } override fun getAll(): List<VenueDto> { return givenDtoList } } ) venueViewModel.start() expectThat(venueViewModel.venues).containsExactly(givenDtoList) } 43
98. EXAMPLE @Test fun `given non-empty dataset when start then load list`() { val givenDtoList = listOf( VenueDto(id = "1", content = "Some data") ) val venueViewModel = VenueViewModel( dataProvider = mock { on { getAll() } doReturn givenDtoList } ) venueViewModel.start() expectThat(venueViewModel.venues).containsExactly(givenDtoList) } 44
99. MOCKING FRAMEWORKS 45
100. MOCKITO @RunWith(MockitoJUnitRunner::class) class PresenterTest { @Mock lateinit var view: View @Mock lateinit var dataProvider: DataProvider @Test fun `given non-empty list when presenter start then display elements on view`() { val elements = listOf( Element(1, "first"), Element(2, "second") ) `when`(dataProvider.getAll()).thenReturn(elements) val presenter = Presenter(view, dataProvider) presenter.start() verify(view).displayItems(elements) } } 46
101. MOCKITO @RunWith(MockitoJUnitRunner::class) class PresenterTest { @Mock lateinit var view: View @Mock lateinit var dataProvider: DataProvider @Test fun `given non-empty list when presenter start then display elements on view`() { val elements = listOf( Element(1, "first"), Element(2, "second") ) `when`(dataProvider.getAll()).thenReturn(elements) val presenter = Presenter(view, dataProvider) presenter.start() verify(view).displayItems(elements) } } @Mock won’t work without it 46
102. MOCKITO @RunWith(MockitoJUnitRunner::class) class PresenterTest { @Mock lateinit var view: View @Mock lateinit var dataProvider: DataProvider @Test fun `given non-empty list when presenter start then display elements on view`() { val elements = listOf( Element(1, "first"), Element(2, "second") ) `when`(dataProvider.getAll()).thenReturn(elements) val presenter = Presenter(view, dataProvider) presenter.start() verify(view).displayItems(elements) } } @Mock won’t work without it 46
103. MOCKITO @RunWith(MockitoJUnitRunner::class) class PresenterTest { @Mock lateinit var view: View @Mock lateinit var dataProvider: DataProvider @Test fun `given non-empty list when presenter start then display elements on view`() { val elements = listOf( Element(1, "first"), Element(2, "second") ) `when`(dataProvider.getAll()).thenReturn(elements) val presenter = Presenter(view, dataProvider) presenter.start() verify(view).displayItems(elements) } } @Mock won’t work without it cannot be val 46
104. MOCKITO @RunWith(MockitoJUnitRunner::class) class PresenterTest { @Mock lateinit var view: View @Mock lateinit var dataProvider: DataProvider @Test fun `given non-empty list when presenter start then display elements on view`() { val elements = listOf( Element(1, "first"), Element(2, "second") ) `when`(dataProvider.getAll()).thenReturn(elements) val presenter = Presenter(view, dataProvider) presenter.start() verify(view).displayItems(elements) } } @Mock won’t work without it cannot be val 46
105. MOCKITO @RunWith(MockitoJUnitRunner::class) class PresenterTest { @Mock lateinit var view: View @Mock lateinit var dataProvider: DataProvider @Test fun `given non-empty list when presenter start then display elements on view`() { val elements = listOf( Element(1, "first"), Element(2, "second") ) `when`(dataProvider.getAll()).thenReturn(elements) val presenter = Presenter(view, dataProvider) presenter.start() verify(view).displayItems(elements) } } @Mock won’t work without it cannot be val reserved word in Kotlin 46
106. MOCKITO @RunWith(MockitoJUnitRunner::class) class PresenterTest { @Mock lateinit var view: View @Mock lateinit var dataProvider: DataProvider @Test fun `given non-empty list when presenter start then display elements on view`() { val elements = listOf( Element(1, "first"), Element(2, "second") ) `when`(dataProvider.getAll()).thenReturn(elements) val presenter = Presenter(view, dataProvider) presenter.start() verify(view).displayItems(elements) } } @Mock won’t work without it cannot be val reserved word in Kotlin 46
107. KOTLIN-MOCKITO class PresenterTest { val view: View = mock() @Test fun `given non-empty list when presenter start then display elements on view`() { val elements = listOf( Element(1, "first"), Element(2, "second") ) val dataProvider: DataProvider = mock { on { getAll() } doReturn elements } val presenter = Presenter(view, dataProvider) presenter.start() verify(view).displayItems(elements) } } 47
108. KOTLIN-MOCKITO class PresenterTest { val view: View = mock() @Test fun `given non-empty list when presenter start then display elements on view`() { val elements = listOf( Element(1, "first"), Element(2, "second") ) val dataProvider: DataProvider = mock { on { getAll() } doReturn elements } val presenter = Presenter(view, dataProvider) presenter.start() verify(view).displayItems(elements) } } inline, reifeid 47
109. KOTLIN-MOCKITO class PresenterTest { val view: View = mock() @Test fun `given non-empty list when presenter start then display elements on view`() { val elements = listOf( Element(1, "first"), Element(2, "second") ) val dataProvider: DataProvider = mock { on { getAll() } doReturn elements } val presenter = Presenter(view, dataProvider) presenter.start() verify(view).displayItems(elements) } } inline, reifeid 47
110. KOTLIN-MOCKITO class PresenterTest { val view: View = mock() @Test fun `given non-empty list when presenter start then display elements on view`() { val elements = listOf( Element(1, "first"), Element(2, "second") ) val dataProvider: DataProvider = mock { on { getAll() } doReturn elements } val presenter = Presenter(view, dataProvider) presenter.start() verify(view).displayItems(elements) } } inline, reifeid clean syntax 47
111. KOTLIN-MOCKITO class PresenterTest { val view: View = mock() @Test fun `given non-empty list when presenter start then display elements on view`() { val elements = listOf( Element(1, "first"), Element(2, "second") ) val dataProvider: DataProvider = mock { on { getAll() } doReturn elements } val presenter = Presenter(view, dataProvider) presenter.start() verify(view).displayItems(elements) } } inline, reifeid clean syntax 47
112. MOCKK class PresenterTest { val view: View = mockk(relaxUnitFun = true) @Test fun `given non-empty list when presenter start then display elements on view`() { val elements = listOf( Element(1, "first"), Element(2, "second") ) val dataProvider = mockk<DataProvider>() every { dataProvider.getAll() } returns elements val presenter = Presenter(view, dataProvider) presenter.start() verify { view.displayItems(elements) } } } 48
113. MOCKING BEST PRACTICES 49
114. MOCKING BEST PRACTICES • Think twice before mocking final classes 49
115. MOCKING BEST PRACTICES • Think twice before mocking final classes • Reuse mocks carefully - no one needs shared state 49
116. MOCKING BEST PRACTICES • Think twice before mocking final classes • Reuse mocks carefully - no one needs shared state • Extract common mocks / fakes to separate classes 49
117. MOCKING BEST PRACTICES • Think twice before mocking final classes • Reuse mocks carefully - no one needs shared state • Extract common mocks / fakes to separate classes • Try to implement your own fakes - you don’t have to trust what’s going inside mocking frameworks 49
118. HOW TO DEAL WITH HUGE CLASSES UNDER TEST? 50
119. FACTORY METHODS + DEFAULT ARGUMENTS class SignUpPresenter( val view: SignUpView, val router: Router, val formValidator: FormValidator, val userProvider: UserProvider, val signUpUseCase: SignUpUseCase ){ /**/ } 51
120. FACTORY METHODS + DEFAULT ARGUMENTS fun createPresenter( router: Router = mock(), signUpView: SignUpView = mock(), userProvider: UserProvider = mock(), formValidator: FormValidator = mock(), signUpUseCase: SignUpUseCase = mock() ): SignUpPresenter { return SignUpPresenter( signUpView, router, formValidator, userProvider, signUpUseCase ) } 52
121. FACTORY METHODS + DEFAULT ARGUMENTS @Test fun `given … when … then propagate error to view`(){ val useCase: SignUpUseCase = mock { on { execute(any(), any()) } doThrow Exception() } val presenter = createPresenter( signUpUseCase = useCase ) verify(signUpView).showError() } 53
122. PATTERNS FOR MOBILE 54
123. MODEL - VIEW - PRESENTER interface View : BaseView { fun addDestination(pub: PubModel) fun addSuggestions(routes: List<RouteElement>) fun updateUserLocations(userLocations: List<UserLocationModel>) } interface Presenter : BasePresenter<View> { fun loadTripSuggestions(from: LatLng, to: PubModel) } 55
124. MODEL - VIEW - PRESENTER interface View : BaseView { fun addDestination(pub: PubModel) fun addSuggestions(routes: List<RouteElement>) fun updateUserLocations(userLocations: List<UserLocationModel>) } interface Presenter : BasePresenter<View> { fun loadTripSuggestions(from: LatLng, to: PubModel) } 55 it("should add suggestions to view") { verify(view).addDestination(givenDestination) }
125. EXECUTING TEST IN MVP FLOW fun <View> Presenter<View>.withFlowOn( view: View, function: View.() -> Unit) { attachView(view) start() function.invoke(view) detachView() } presenter.withFlowOn(view){ it("should add suggestions to view") { verify(view).addDestination(givenDestination) } } 56
126. VIEWMODEL abstract class ViewModel { protected fun onCleared() {} } 57
127. VIEWMODEL abstract class ViewModel { protected fun onCleared() {} } 57 abstract class BaseViewModel : ViewModel() { open fun close() { //clear resources } override fun onCleared() { close() super.onCleared() } }
128. VIEWMODEL abstract class ViewModel { protected fun onCleared() {} } 57 abstract class BaseViewModel : ViewModel() { open fun close() { //clear resources } override fun onCleared() { close() super.onCleared() } } invoke close in test flow
129. VIEWMODEL abstract class ViewModel { protected fun onCleared() {} } 57 abstract class BaseViewModel : ViewModel() { open fun close() { //clear resources } override fun onCleared() { close() super.onCleared() } } invoke close in test flow
130. VIEWMODEL package androidx.lifecycle fun ViewModel.clear(){ onCleared() }
131. MODEL-VIEW-VIEWMODEL 59 class SignUpViewModel( private val useCase: SignUpUseCase, private val router: Router ) : BaseViewModel() { var progressVisible by observable(false) fun signUpClick() { useCase.execute(signUpEntity) .doOnSubscribe { progressVisible = true } .doOnComplete { progressVisible = false } .subscribe({},{}) } fun signInClick() { router.openSignIn() } }
132. MODEL-VIEW-VIEWMODEL fun <VM : BaseViewModel> VM.withFlow(testBody: (VM) -> Unit) { start() testBody.invoke(this) close() } viewModel.withFlow{ signInClick() verify(router).openSignIn() } 60
133. MODEL- VIEW-INTENT 61 interface View : MvpView { fun initIntent(): Observable<ConversationId> fun sendMessageIntent(): Observable<Message> fun openProfileIntent(): Observable<ProfileId> fun closeIntent(): Observable<Any> fun render(viewState: ChatViewState) } abstract class Presenter : MviBasePresenter<View, ChatViewState>()
134. MODEL- VIEW-INTENT 61 interface View : MvpView { fun initIntent(): Observable<ConversationId> fun sendMessageIntent(): Observable<Message> fun openProfileIntent(): Observable<ProfileId> fun closeIntent(): Observable<Any> fun render(viewState: ChatViewState) } abstract class Presenter : MviBasePresenter<View, ChatViewState>() verify(view).what???()
135. val renderedStates = mutableListOf<ChatViewState>() val initSubject = PublishSubject.create<ConversationId>() val sendMessageSubject = PublishSubject.create<Message>() val openProfileSubject = PublishSubject.create<ProfileId>() val view: ChatContract.View = object : ChatContract.View { override fun initIntent(): Observable<Long> = initSubject override fun sendMessageIntent(): Observable<Message> = sendMessageSubject override fun openProfileIntent(): Observable<ProfileId> = openProfileSubject override fun render(viewState: ChatViewState) { renderedStates.add(viewState) } } init { presenter.attachView(view) } VIEW ROBOT 62
136. val renderedStates = mutableListOf<ChatViewState>() val initSubject = PublishSubject.create<ConversationId>() val sendMessageSubject = PublishSubject.create<Message>() val openProfileSubject = PublishSubject.create<ProfileId>() val view: ChatContract.View = object : ChatContract.View { override fun initIntent(): Observable<Long> = initSubject override fun sendMessageIntent(): Observable<Message> = sendMessageSubject override fun openProfileIntent(): Observable<ProfileId> = openProfileSubject override fun render(viewState: ChatViewState) { renderedStates.add(viewState) } } init { presenter.attachView(view) } VIEW ROBOT subjects to control intents 62
137. val renderedStates = mutableListOf<ChatViewState>() val initSubject = PublishSubject.create<ConversationId>() val sendMessageSubject = PublishSubject.create<Message>() val openProfileSubject = PublishSubject.create<ProfileId>() val view: ChatContract.View = object : ChatContract.View { override fun initIntent(): Observable<Long> = initSubject override fun sendMessageIntent(): Observable<Message> = sendMessageSubject override fun openProfileIntent(): Observable<ProfileId> = openProfileSubject override fun render(viewState: ChatViewState) { renderedStates.add(viewState) } } init { presenter.attachView(view) } VIEW ROBOT subjects to control intents 62
138. val renderedStates = mutableListOf<ChatViewState>() val initSubject = PublishSubject.create<ConversationId>() val sendMessageSubject = PublishSubject.create<Message>() val openProfileSubject = PublishSubject.create<ProfileId>() val view: ChatContract.View = object : ChatContract.View { override fun initIntent(): Observable<Long> = initSubject override fun sendMessageIntent(): Observable<Message> = sendMessageSubject override fun openProfileIntent(): Observable<ProfileId> = openProfileSubject override fun render(viewState: ChatViewState) { renderedStates.add(viewState) } } init { presenter.attachView(view) } VIEW ROBOT subjects to control intents view states are added to list 62
139. val renderedStates = mutableListOf<ChatViewState>() val initSubject = PublishSubject.create<ConversationId>() val sendMessageSubject = PublishSubject.create<Message>() val openProfileSubject = PublishSubject.create<ProfileId>() val view: ChatContract.View = object : ChatContract.View { override fun initIntent(): Observable<Long> = initSubject override fun sendMessageIntent(): Observable<Message> = sendMessageSubject override fun openProfileIntent(): Observable<ProfileId> = openProfileSubject override fun render(viewState: ChatViewState) { renderedStates.add(viewState) } } init { presenter.attachView(view) } VIEW ROBOT subjects to control intents view states are added to list 62
140. on("send message") { val presenter = ChatPresenter(useCase, TestSchedulersFacade()) val robot = ChatViewRobot(presenter) robot.start(conversationId) it("should send message and update list") { robot.sendMessage(message) val expectedState = ViewState(items = items.plus(message)) robot.assertViewStatesRendered { listOf( initState, fetchedMessagesState, messageSendingState, messageSentState, expectedState ) } } } VIEW ROBOT 63
141. VIEW ROBOT
142. VIEW ROBOT • Abstraction for your view
143. VIEW ROBOT • Abstraction for your view • Can be used in MVI, MVVM, MVP
144. VIEW ROBOT • Abstraction for your view • Can be used in MVI, MVVM, MVP • Robot records state changes
145. VIEW ROBOT • Abstraction for your view • Can be used in MVI, MVVM, MVP • Robot records state changes • Then you can test validate full flow in fast test
146. SPECIFICATIONS 65
147. SPECIFICATIONS 65
148. • test + specification -> system documentation SPECIFICATIONS 65
149. • test + specification -> system documentation • helps you understand product better SPECIFICATIONS 65
150. • test + specification -> system documentation • helps you understand product better • fits great with TDD and BDD SPECIFICATIONS 65
151. • test + specification -> system documentation • helps you understand product better • fits great with TDD and BDD • makes it easier to separate implementation from behavior SPECIFICATIONS 65
152. KOTLINTEST SPECIFICATION class DistanceConverterSpec : BehaviorSpec({ Given("some preconditions"){ When("execute action"){ Then("perform assertions"){ } Then("perform other assertion"){ } } When("execute other action"){ Then("check and perform assertion"){ throw AssertionError() } } } }) 66
153. KOTLINTEST SPECIFICATION 67
154. KOTLINTEST SPECIFICATION 67
155. SPEK SPECIFICATION import org.spekframework.spek2.Spek import org.spekframework.spek2.style.specification.describe object DistanceConverterSpek : Spek({ describe("system behavior") { it("should do something") { } } }) 68
158. SPEK SPECIFICATION val converter by memoized(mode = CachingMode.EACH_GROUP){ DistanceConverter() } REUSE OBJECT BETWEEN TESTS CAREFULLY! 70
159. SPEK SPECIFICATION val converter by memoized(mode = CachingMode.EACH_GROUP){ DistanceConverter() } val converter by memoized(mode = CachingMode.TEST){ DistanceConverter() } REUSE OBJECT BETWEEN TESTS CAREFULLY! 70
160. SUMMARY 71
161. SUMMARY 71
162. • Know your frameworks! SUMMARY 71
163. • Know your frameworks! • Keep unit test isolated SUMMARY 71
164. • Know your frameworks! • Keep unit test isolated • Test behavior, not implementation SUMMARY 71
165. • Know your frameworks! • Keep unit test isolated • Test behavior, not implementation • Make use of language features (infix notation, lambdas, extension functions) SUMMARY 71
166. • Know your frameworks! • Keep unit test isolated • Test behavior, not implementation • Make use of language features (infix notation, lambdas, extension functions) • Structure your tests well SUMMARY 71
167. LEARNING RESOURCES 72
168. LEARNING RESOURCES 72
169. • https://github.com/rozkminiacz/KotlinUnitTesting LEARNING RESOURCES 72
170. • https://github.com/rozkminiacz/KotlinUnitTesting • https://strikt.io LEARNING RESOURCES 72
171. • https://github.com/rozkminiacz/KotlinUnitTesting • https://strikt.io • https://mockk.io LEARNING RESOURCES 72
172. • https://github.com/rozkminiacz/KotlinUnitTesting • https://strikt.io • https://mockk.io • https://junit.org/junit5/docs/current/user-guide/ LEARNING RESOURCES 72
173. • https://github.com/rozkminiacz/KotlinUnitTesting • https://strikt.io • https://mockk.io • https://junit.org/junit5/docs/current/user-guide/ • https://medium.com/@rozkminiacz LEARNING RESOURCES 72
174. JAROSŁAW MICHALIK Android Developer https://twitter.com/rozkminia https://medium.com/@rozkminiacz https://github.com/rozkminiacz/ https://michalik.tech