Update mockito and mockito-kotlin dependencies and fix all tests

Author: Serchinastico

app/build.gradle

@@ -47,8 +47,9 @@ dependencies {
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.1.0"
   implementation "joda-time:joda-time:2.10"
   testImplementation "junit:junit:4.12"
-  testImplementation "org.mockito:mockito-core:2.23.0"
-  testImplementation "com.nhaarman:mockito-kotlin:1.6.0"
+  testImplementation "org.mockito:mockito-core:2.23.4"
+  testImplementation "com.nhaarman.mockitokotlin2:mockito-kotlin:2.1.0"
+  testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.1.0"
   androidTestImplementation "com.android.support.test:runner:1.0.2"
   androidTestImplementation "com.android.support.test.espresso:espresso-core:3.0.2"
 }

app/src/test/java/com/karumi/kataloginlogoutkotlin/LogInLogOutKataTest.kt

@@ -2,10 +2,11 @@ package com.karumi.kataloginlogoutkotlin
 
 import arrow.core.left
 import arrow.core.right
-import com.nhaarman.mockito_kotlin.whenever
+import com.nhaarman.mockitokotlin2.whenever
 import junit.framework.TestCase.assertEquals
-import junit.framework.TestCase.assertTrue
 import junit.framework.TestCase.assertFalse
+import junit.framework.TestCase.assertTrue
+import kotlinx.coroutines.runBlocking
 import org.joda.time.DateTime
 import org.junit.Before
 import org.junit.Test
@@ -34,49 +35,52 @@ class LogInLogOutKataTest {
     }
 
     @Test
-    fun `should return an invalid username error if the username contains the first invalid char char chars`() {
-        val logInResult = logInLogOutKata.logIn("ad,min", ANY_INVALID_PASSWORD)
+    fun `should return an invalid username error if the username contains the first invalid char char chars`() =
+        runBlocking {
+            val logInResult = logInLogOutKata.logIn("ad,min", ANY_INVALID_PASSWORD)
 
-        assertEquals(InvalidUsername.left(), logInResult)
-    }
+            assertEquals(InvalidUsername.left(), logInResult)
+        }
 
     @Test
-    fun `should return an invalid username error if the username contains the second invalid char char chars`() {
-        val logInResult = logInLogOutKata.logIn("ad.min", ANY_INVALID_PASSWORD)
+    fun `should return an invalid username error if the username contains the second invalid char char chars`() =
+        runBlocking {
+            val logInResult = logInLogOutKata.logIn("ad.min", ANY_INVALID_PASSWORD)
 
-        assertEquals(InvalidUsername.left(), logInResult)
-    }
+            assertEquals(InvalidUsername.left(), logInResult)
+        }
 
     @Test
-    fun `should return an invalid username error if the username contains the third invalid char char chars`() {
-        val logInResult = logInLogOutKata.logIn("ad;min", ANY_INVALID_PASSWORD)
+    fun `should return an invalid username error if the username contains the third invalid char char chars`() =
+        runBlocking {
+            val logInResult = logInLogOutKata.logIn("ad;min", ANY_INVALID_PASSWORD)
 
-        assertEquals(InvalidUsername.left(), logInResult)
-    }
+            assertEquals(InvalidUsername.left(), logInResult)
+        }
 
     @Test
-    fun `should return an invalid credentials error if the username is not correct`() {
+    fun `should return an invalid credentials error if the username is not correct`() = runBlocking {
         val logInResult = logInLogOutKata.logIn(ANY_INVALID_USERNAME, ANY_VALID_PASSWORD)
 
         assertEquals(InvalidCredentials.left(), logInResult)
     }
 
     @Test
-    fun `should return an invalid credentials error if the password is not correct`() {
+    fun `should return an invalid credentials error if the password is not correct`() = runBlocking {
         val logInResult = logInLogOutKata.logIn(ANY_VALID_USERNAME, ANY_INVALID_PASSWORD)
 
         assertEquals(InvalidCredentials.left(), logInResult)
     }
 
     @Test
-    fun `should return the user username and a success result if the user and password are corrects`() {
+    fun `should return the user username and a success result if the user and password are corrects`() = runBlocking {
         val logInResult = logInLogOutKata.logIn(ANY_VALID_USERNAME, ANY_VALID_PASSWORD)
 
         assertEquals(ANY_VALID_USERNAME.right(), logInResult)
     }
 
     @Test
-    fun `should return an error if the second when the log out is performed is odd`() {
+    fun `should return an error if the second when the log out is performed is odd`() = runBlocking {
         givenNowIs(DateTime(3))
 
         val logOutResult = logInLogOutKata.logOut()
@@ -85,7 +89,7 @@ class LogInLogOutKataTest {
     }
 
     @Test
-    fun `should return success if the second when the log out is performed is even`() {
+    fun `should return success if the second when the log out is performed is even`() = runBlocking {
         givenNowIs(DateTime(2))
 
         val logOutResult = logInLogOutKata.logOut()

app/src/test/java/com/karumi/kataloginlogoutkotlin/PresenterTest.kt

@@ -3,14 +3,19 @@ package com.karumi.kataloginlogoutkotlin
 import arrow.core.Either
 import arrow.core.left
 import arrow.core.right
-import com.nhaarman.mockito_kotlin.any
-import com.nhaarman.mockito_kotlin.verify
-import com.nhaarman.mockito_kotlin.whenever
+import com.nhaarman.mockitokotlin2.any
+import com.nhaarman.mockitokotlin2.verify
+import com.nhaarman.mockitokotlin2.whenever
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.asCoroutineDispatcher
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.setMain
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.mockito.Mock
 import org.mockito.junit.MockitoJUnitRunner
+import java.util.concurrent.Executors
 
 @RunWith(MockitoJUnitRunner::class)
 class PresenterTest {
@@ -29,61 +34,62 @@ class PresenterTest {
 
     @Before
     fun setUp() {
+        Dispatchers.setMain(Executors.newSingleThreadExecutor().asCoroutineDispatcher())
         presenter = Presenter(kata, view)
     }
 
     @Test
-    fun `should show an invalid credentials error if the log in process returns InvalidCredentials`() {
+    fun `should show an invalid credentials error if the log in process returns InvalidCredentials`() = runBlocking {
         givenTheLogInProcessReturns(InvalidCredentials.left())
 
-        presenter.onLogInButtonTap(ANY_USERNAME, ANY_PASS)
+        presenter.onLogInButtonTap(ANY_USERNAME, ANY_PASS).join()
 
         verify(view).showError(R.string.log_in_error_message)
     }
 
     @Test
-    fun `should show an invalid username error if the log in process returns InvalidUsername`() {
+    fun `should show an invalid username error if the log in process returns InvalidUsername`() = runBlocking {
         givenTheLogInProcessReturns(InvalidUsername.left())
 
-        presenter.onLogInButtonTap(ANY_USERNAME, ANY_PASS)
+        presenter.onLogInButtonTap(ANY_USERNAME, ANY_PASS).join()
 
         verify(view).showError(R.string.invalid_username_error_message)
     }
 
     @Test
-    fun `should show a could not perform log out error if the log out process fails`() {
+    fun `should show a could not perform log out error if the log out process fails`() = runBlocking {
         givenTheLogOutProcessReturns(false)
 
-        presenter.onLogOutButtonTap()
+        presenter.onLogOutButtonTap().join()
 
         verify(view).showError(R.string.log_out_error_message)
     }
 
     @Test
-    fun `should hide the log in form and show the log out form if the log in process finished properly`() {
-            givenTheLogInProcessReturns(ANY_USERNAME.right())
+    fun `should hide the log in form and show the log out form if the log in process finished properly`() = runBlocking {
+        givenTheLogInProcessReturns(ANY_USERNAME.right())
 
-            presenter.onLogInButtonTap(ANY_USERNAME, ANY_PASS)
+        presenter.onLogInButtonTap(ANY_USERNAME, ANY_PASS).join()
 
-            verify(view).hideLogInForm()
-            verify(view).showLogOutForm()
-        }
+        verify(view).hideLogInForm()
+        verify(view).showLogOutForm()
+    }
 
     @Test
-    fun `should hide the log out form and show the log in form if the log out process finished properly`() {
-            givenTheLogOutProcessReturns(true)
+    fun `should hide the log out form and show the log in form if the log out process finished properly`() = runBlocking {
+        givenTheLogOutProcessReturns(true)
 
-            presenter.onLogOutButtonTap()
+        presenter.onLogOutButtonTap().join()
 
-            verify(view).hideLogOutForm()
-            verify(view).showLogInForm()
-        }
+        verify(view).hideLogOutForm()
+        verify(view).showLogInForm()
+    }
 
     private fun givenTheLogOutProcessReturns(result: Boolean) {
-        whenever(kata.logOut()).thenReturn(result)
+        runBlocking { whenever(kata.logOut()).thenReturn(result) }
     }
 
     private fun givenTheLogInProcessReturns(result: Either<LogInError, String>) {
-        whenever(kata.logIn(any(), any())).thenReturn(result)
+        runBlocking { whenever(kata.logIn(any(), any())).thenReturn(result) }
     }
 }