Fix code analysis errors

With that updated Mockito, so `verifyZeroInteractions` is now `verifyNoInteractions`

app/src/sharedTest/java/org/fnives/test/showcase/testutils/storage/TestDatabaseInitialization.kt

@@ -24,8 +24,10 @@ object TestDatabaseInitialization {
     }
 
     fun overwriteDatabaseInitialization(dispatcher: CoroutineDispatcher) {
-        loadKoinModules(module {
+        loadKoinModules(
+            module {
                 single { create(androidContext(), dispatcher) }
-        })
+            }
+        )
     }
 }

app/src/test/java/org/fnives/test/showcase/ui/home/MainViewModelTest.kt

@@ -24,8 +24,8 @@ import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
+import org.mockito.kotlin.verifyNoInteractions
 import org.mockito.kotlin.verifyNoMoreInteractions
-import org.mockito.kotlin.verifyZeroInteractions
 import org.mockito.kotlin.whenever
 
 @Suppress("TestFunctionName")
@@ -150,7 +150,7 @@ internal class MainViewModelTest {
         sut.onRefresh()
         testScheduler.advanceUntilIdle()
 
-        verifyZeroInteractions(mockFetchContentUseCase)
+        verifyNoInteractions(mockFetchContentUseCase)
     }
 
     @DisplayName("GIVEN non loading viewModel WHEN refreshing THEN usecase is called")
@@ -209,8 +209,8 @@ internal class MainViewModelTest {
         sut.onFavouriteToggleClicked(ContentId("c"))
         testScheduler.advanceUntilIdle()
 
-        verifyZeroInteractions(mockRemoveContentFromFavouritesUseCase)
-        verifyZeroInteractions(mockAddContentToFavouriteUseCase)
+        verifyNoInteractions(mockRemoveContentFromFavouritesUseCase)
+        verifyNoInteractions(mockAddContentToFavouriteUseCase)
     }
 
     @DisplayName("GIVEN success content list viewModel WHEN toggling a favourite contentId THEN remove favourite usecase is called")
@@ -229,7 +229,7 @@ internal class MainViewModelTest {
 
         runBlocking { verify(mockRemoveContentFromFavouritesUseCase, times(1)).invoke(ContentId("b")) }
         verifyNoMoreInteractions(mockRemoveContentFromFavouritesUseCase)
-        verifyZeroInteractions(mockAddContentToFavouriteUseCase)
+        verifyNoInteractions(mockAddContentToFavouriteUseCase)
     }
 
     @DisplayName("GIVEN success content list viewModel WHEN toggling a not favourite contentId THEN add favourite usecase is called")
@@ -246,7 +246,7 @@ internal class MainViewModelTest {
         sut.onFavouriteToggleClicked(ContentId("a"))
         testScheduler.advanceUntilIdle()
 
-        verifyZeroInteractions(mockRemoveContentFromFavouritesUseCase)
+        verifyNoInteractions(mockRemoveContentFromFavouritesUseCase)
         runBlocking { verify(mockAddContentToFavouriteUseCase, times(1)).invoke(ContentId("a")) }
         verifyNoMoreInteractions(mockAddContentToFavouriteUseCase)
     }

codekata/core.again.instructionset.md

@@ -162,7 +162,7 @@ fun withoutSessionTheUserIsNotLoggedIn() = runTest {
     val actual = isUserLoggedInUseCase.invoke()
 
     Assertions.assertFalse(actual, "User is expected to be not logged in")
-    verifyZeroInteractions(mockSessionExpirationListener)
+    verifyNoInteractions(mockSessionExpirationListener)
 }
 ```
 
@@ -187,7 +187,7 @@ And just verify:
 Assertions.assertEquals(Answer.Success(LoginStatus.SUCCESS), answer)
 Assertions.assertTrue(actual, "User is expected to be logged in")
 Assertions.assertEquals(expectedSession, fakeUserDataLocalStorage.session)
-verifyZeroInteractions(mockSessionExpirationListener)
+verifyNoInteractions(mockSessionExpirationListener)
 ```
 
 With this, looks like our Integration works correctly. Requests are called, proper response is received, login state is changed.
@@ -214,7 +214,7 @@ And do our verifications, aka not logged in, not session expired and the correct
 Assertions.assertEquals(Answer.Success(loginError), answer)
 Assertions.assertFalse(actual, "User is expected to be not logged in")
 Assertions.assertEquals(null, fakeUserDataLocalStorage.session)
-verifyZeroInteractions(mockSessionExpirationListener)
+verifyNoInteractions(mockSessionExpirationListener)
 ```
 
 Now we just need to declare our parameters for our test:
@@ -247,7 +247,7 @@ fun networkInputError(authScenario: AuthScenario) = runTest {
     Assertions.assertTrue(answer is Answer.Error, "Answer is expected to be an Error")
     Assertions.assertFalse(actual, "User is expected to be not logged in")
     Assertions.assertEquals(null, fakeUserDataLocalStorage.session)
-    verifyZeroInteractions(mockSessionExpirationListener)
+    verifyNoInteractions(mockSessionExpirationListener)
 }
 
 //...
@@ -282,7 +282,7 @@ fun loginInvalidCredentials() = runTest {
     Assertions.assertEquals(Answer.Success(LoginStatus.INVALID_CREDENTIALS), answer)
     Assertions.assertFalse(actual, "User is expected to be not logged in")
     Assertions.assertEquals(null, fakeUserDataLocalStorage.session)
-    verifyZeroInteractions(mockSessionExpirationListener)
+    verifyNoInteractions(mockSessionExpirationListener)
 }
 ```
 
@@ -305,7 +305,7 @@ And we verify the user is indeed logged out now:
 ```kotlin
 Assertions.assertFalse(actual, "User is expected to be logged out")
 Assertions.assertEquals(null, fakeUserDataLocalStorage.session)
-verifyZeroInteractions(mockSessionExpirationListener)
+verifyNoInteractions(mockSessionExpirationListener)
 ```
 
 ### 7. `logoutReleasesContent`

codekata/core.instructionset.md

@@ -56,7 +56,7 @@ When the class is created, the delegate should not yet be touched, so we start t
 @DisplayName("WHEN nothing is changed THEN delegate is not touched") // this will show up when running our tests and is a great way to document what we are testing
 @Test // this defines that this method is a test, needs to be org.junit.jupiter.api.Test
 fun verifyNoInteractionsIfNoInvocations() {
-    verifyZeroInteractions(mockSessionExpirationListener) // we verify that our mock object's functions / properties have not been touched
+    verifyNoInteractions(mockSessionExpirationListener) // we verify that our mock object's functions / properties have not been touched
 }
 ```
 
@@ -131,8 +131,8 @@ Lastly we add verification:
 
 ```kotlin
 Assertions.assertEquals(expected, actual) // assert the result is what we expected
-verifyZeroInteractions(mockLoginRemoteSource) // assert no request was called
-verifyZeroInteractions(mockUserDataLocalStorage) // assert we didn't modify our storage
+verifyNoInteractions(mockLoginRemoteSource) // assert no request was called
+verifyNoInteractions(mockUserDataLocalStorage) // assert we didn't modify our storage
 ```
 
 But something is wrong, the invoke method cannot be executed since it's a suspending function.
@@ -148,8 +148,8 @@ fun emptyUserNameReturnsLoginStatusError() = runTest {
     val actual = sut.invoke(LoginCredentials("", "a"))
 
     Assertions.assertEquals(expected, actual)
-    verifyZeroInteractions(mockLoginRemoteSource)
-    verifyZeroInteractions(mockUserDataLocalStorage)
+    verifyNoInteractions(mockLoginRemoteSource)
+    verifyNoInteractions(mockUserDataLocalStorage)
 }
 ```
 
@@ -172,8 +172,8 @@ fun emptyPasswordNameReturnsLoginStatusError() = runTest {
     val actual = sut.invoke(LoginCredentials("a", ""))
 
     Assertions.assertEquals(expected, actual)
-    verifyZeroInteractions(mockLoginRemoteSource)
-    verifyZeroInteractions(mockUserDataLocalStorage)
+    verifyNoInteractions(mockLoginRemoteSource)
+    verifyNoInteractions(mockUserDataLocalStorage)
 }
 ```
 
@@ -211,7 +211,7 @@ And finally verification:
 
 ```kotlin
 Assertions.assertEquals(expected, actual)
-verifyZeroInteractions(mockUserDataLocalStorage)
+verifyNoInteractions(mockUserDataLocalStorage)
 ```
 
 Together:
@@ -226,7 +226,7 @@ fun invalidLoginResponseReturnInvalidCredentials() = runTest {
     val actual = sut.invoke(LoginCredentials("a", "b"))
 
     Assertions.assertEquals(expected, actual)
-    verifyZeroInteractions(mockUserDataLocalStorage)
+    verifyNoInteractions(mockUserDataLocalStorage)
 }
 ```
 
@@ -291,7 +291,7 @@ Verification:
 
 ```kotlin
 Assertions.assertEquals(expected, actual)
-verifyZeroInteractions(mockUserDataLocalStorage)
+verifyNoInteractions(mockUserDataLocalStorage)
 ```
 
 Together:
@@ -308,7 +308,7 @@ fun invalidResponseResultsInErrorReturned() = runTest {
     val actual = sut.invoke(LoginCredentials("a", "b"))
 
     Assertions.assertEquals(expected, actual)
-    verifyZeroInteractions(mockUserDataLocalStorage)
+    verifyNoInteractions(mockUserDataLocalStorage)
 }
 ```
 #### Lessons learned

codekata/networking.instructionset.md

@@ -328,7 +328,7 @@ Assertions.assertEquals("login-access", contentRequestAfterRefreshed.getHeader("
 // this matches the data from the success_response_login.json
 val expectedSavedSession = Session(accessToken = "login-access", refreshToken = "login-refresh")
 verify(mockNetworkSessionLocalStorage, times(1)).session = expectedSavedSession
-verifyZeroInteractions(mockNetworkSessionExpirationListener)
+verifyNoInteractions(mockNetworkSessionExpirationListener)
 ```
 
 ### 2. `failingRefreshResultsInSessionExpiration`

core/src/test/java/org/fnives/test/showcase/core/content/AddContentToFavouriteUseCaseTest.kt

@@ -13,8 +13,8 @@ import org.mockito.kotlin.doThrow
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
+import org.mockito.kotlin.verifyNoInteractions
 import org.mockito.kotlin.verifyNoMoreInteractions
-import org.mockito.kotlin.verifyZeroInteractions
 import org.mockito.kotlin.whenever
 
 @Suppress("TestFunctionName")
@@ -33,7 +33,7 @@ internal class AddContentToFavouriteUseCaseTest {
     @DisplayName("WHEN nothing happens THEN the storage is not touched")
     @Test
     fun initializationDoesntAffectStorage() {
-        verifyZeroInteractions(mockFavouriteContentLocalStorage)
+        verifyNoInteractions(mockFavouriteContentLocalStorage)
     }
 
     @DisplayName("GIVEN contentId WHEN called THEN storage is called")

core/src/test/java/org/fnives/test/showcase/core/content/FetchContentUseCaseTest.kt

@@ -11,8 +11,8 @@ import org.mockito.kotlin.doThrow
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
+import org.mockito.kotlin.verifyNoInteractions
 import org.mockito.kotlin.verifyNoMoreInteractions
-import org.mockito.kotlin.verifyZeroInteractions
 import org.mockito.kotlin.whenever
 
 @Suppress("TestFunctionName")
@@ -31,7 +31,7 @@ internal class FetchContentUseCaseTest {
     @DisplayName("WHEN nothing happens THEN the storage is not touched")
     @Test
     fun initializationDoesntAffectRepository() {
-        verifyZeroInteractions(mockContentRepository)
+        verifyNoInteractions(mockContentRepository)
     }
 
     @DisplayName("WHEN called THEN repository is called")

core/src/test/java/org/fnives/test/showcase/core/content/RemoveContentFromFavouritesUseCaseTest.kt

@@ -13,8 +13,8 @@ import org.mockito.kotlin.doThrow
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
+import org.mockito.kotlin.verifyNoInteractions
 import org.mockito.kotlin.verifyNoMoreInteractions
-import org.mockito.kotlin.verifyZeroInteractions
 import org.mockito.kotlin.whenever
 
 @Suppress("TestFunctionName")
@@ -33,7 +33,7 @@ internal class RemoveContentFromFavouritesUseCaseTest {
     @DisplayName("WHEN nothing happens THEN the storage is not touched")
     @Test
     fun initializationDoesntAffectStorage() {
-        verifyZeroInteractions(mockFavouriteContentLocalStorage)
+        verifyNoInteractions(mockFavouriteContentLocalStorage)
     }
 
     @DisplayName("GIVEN contentId WHEN called THEN storage is called")

core/src/test/java/org/fnives/test/showcase/core/integration/AuthIntegrationTest.kt

@@ -38,7 +38,7 @@ import org.koin.test.KoinTest
 import org.koin.test.get
 import org.koin.test.inject
 import org.mockito.kotlin.mock
-import org.mockito.kotlin.verifyZeroInteractions
+import org.mockito.kotlin.verifyNoInteractions
 import java.util.stream.Stream
 
 @OptIn(ExperimentalCoroutinesApi::class)
@@ -86,7 +86,7 @@ class AuthIntegrationTest : KoinTest {
         val actual = isUserLoggedInUseCase.invoke()
 
         Assertions.assertFalse(actual, "User is expected to be not logged in")
-        verifyZeroInteractions(mockSessionExpirationListener)
+        verifyNoInteractions(mockSessionExpirationListener)
     }
 
     @DisplayName("GIVEN no session WHEN user is logging in THEN they get session")
@@ -101,7 +101,7 @@ class AuthIntegrationTest : KoinTest {
         Assertions.assertEquals(Answer.Success(LoginStatus.SUCCESS), answer)
         Assertions.assertTrue(actual, "User is expected to be logged in")
         Assertions.assertEquals(expectedSession, fakeUserDataLocalStorage.session)
-        verifyZeroInteractions(mockSessionExpirationListener)
+        verifyNoInteractions(mockSessionExpirationListener)
     }
 
     @MethodSource("localInputErrorArguments")
@@ -113,7 +113,7 @@ class AuthIntegrationTest : KoinTest {
         Assertions.assertEquals(Answer.Success(loginError), answer)
         Assertions.assertFalse(actual, "User is expected to be not logged in")
         Assertions.assertEquals(null, fakeUserDataLocalStorage.session)
-        verifyZeroInteractions(mockSessionExpirationListener)
+        verifyNoInteractions(mockSessionExpirationListener)
     }
 
     @MethodSource("networkErrorArguments")
@@ -127,7 +127,7 @@ class AuthIntegrationTest : KoinTest {
         Assertions.assertTrue(answer is Answer.Error, "Answer is expected to be an Error")
         Assertions.assertFalse(actual, "User is expected to be not logged in")
         Assertions.assertEquals(null, fakeUserDataLocalStorage.session)
-        verifyZeroInteractions(mockSessionExpirationListener)
+        verifyNoInteractions(mockSessionExpirationListener)
     }
 
     @DisplayName("GIVEN invalid credentials response WHEN user is logging in THEN they get proper error")
@@ -141,7 +141,7 @@ class AuthIntegrationTest : KoinTest {
         Assertions.assertEquals(Answer.Success(LoginStatus.INVALID_CREDENTIALS), answer)
         Assertions.assertFalse(actual, "User is expected to be not logged in")
         Assertions.assertEquals(null, fakeUserDataLocalStorage.session)
-        verifyZeroInteractions(mockSessionExpirationListener)
+        verifyNoInteractions(mockSessionExpirationListener)
     }
 
     @DisplayName("GIVEN logged in user WHEN user is logging out THEN they no longer have a session")
@@ -155,7 +155,7 @@ class AuthIntegrationTest : KoinTest {
 
         Assertions.assertFalse(actual, "User is expected to be logged out")
         Assertions.assertEquals(null, fakeUserDataLocalStorage.session)
-        verifyZeroInteractions(mockSessionExpirationListener)
+        verifyNoInteractions(mockSessionExpirationListener)
     }
 
     @DisplayName("GIVEN logged in user WHEN user is logging out THEN content is cleared")

core/src/test/java/org/fnives/test/showcase/core/integration/ContentIntegrationTest.kt

@@ -38,7 +38,7 @@ import org.koin.core.context.stopKoin
 import org.koin.test.KoinTest
 import org.koin.test.inject
 import org.mockito.kotlin.mock
-import org.mockito.kotlin.verifyZeroInteractions
+import org.mockito.kotlin.verifyNoInteractions
 
 @OptIn(ExperimentalCoroutinesApi::class)
 class ContentIntegrationTest : KoinTest {
@@ -97,7 +97,7 @@ class ContentIntegrationTest : KoinTest {
         }
 
         Assertions.assertEquals(expected, actual.await())
-        verifyZeroInteractions(mockSessionExpirationListener)
+        verifyNoInteractions(mockSessionExpirationListener)
         Assertions.assertSame(session, fakeUserDataLocalStorage.session)
     }
 
@@ -120,7 +120,7 @@ class ContentIntegrationTest : KoinTest {
         }
 
         Assertions.assertEquals(expected, actual.await())
-        verifyZeroInteractions(mockSessionExpirationListener)
+        verifyNoInteractions(mockSessionExpirationListener)
         Assertions.assertSame(session, fakeUserDataLocalStorage.session)
     }
 
@@ -150,7 +150,7 @@ class ContentIntegrationTest : KoinTest {
         }
 
         Assertions.assertEquals(expected, actual.await())
-        verifyZeroInteractions(mockSessionExpirationListener)
+        verifyNoInteractions(mockSessionExpirationListener)
         Assertions.assertSame(session, fakeUserDataLocalStorage.session)
     }
 
@@ -201,7 +201,7 @@ class ContentIntegrationTest : KoinTest {
 
         Assertions.assertIterableEquals(expected, actual.await())
         Assertions.assertEquals(expected.last(), verifyCaching.await())
-        verifyZeroInteractions(mockSessionExpirationListener)
+        verifyNoInteractions(mockSessionExpirationListener)
         Assertions.assertSame(session, fakeUserDataLocalStorage.session)
     }
 
@@ -229,7 +229,7 @@ class ContentIntegrationTest : KoinTest {
         }
 
         Assertions.assertIterableEquals(expected, actual.await())
-        verifyZeroInteractions(mockSessionExpirationListener)
+        verifyNoInteractions(mockSessionExpirationListener)
         Assertions.assertSame(session, fakeUserDataLocalStorage.session)
     }
 
@@ -268,7 +268,7 @@ class ContentIntegrationTest : KoinTest {
         Assertions.assertTrue((actualValues[1] as Resource.Error).error is NetworkException, "Resource is Network Error")
         Assertions.assertEquals(expected[2], actualValues[2])
         Assertions.assertEquals(expected[3], actualValues[3])
-        verifyZeroInteractions(mockSessionExpirationListener)
+        verifyNoInteractions(mockSessionExpirationListener)
         Assertions.assertSame(session, fakeUserDataLocalStorage.session)
     }
 
@@ -331,7 +331,7 @@ class ContentIntegrationTest : KoinTest {
         }
 
         Assertions.assertIterableEquals(expected, actual.await())
-        verifyZeroInteractions(mockSessionExpirationListener)
+        verifyNoInteractions(mockSessionExpirationListener)
         val expectedSession = Session(accessToken = "refreshed-access", refreshToken = "refreshed-refresh")
         Assertions.assertEquals(expectedSession, fakeUserDataLocalStorage.session)
     }

core/src/test/java/org/fnives/test/showcase/core/integration/SessionExpirationIntegrationTest.kt

@@ -34,8 +34,8 @@ import org.koin.test.inject
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
+import org.mockito.kotlin.verifyNoInteractions
 import org.mockito.kotlin.verifyNoMoreInteractions
-import org.mockito.kotlin.verifyZeroInteractions
 
 @OptIn(ExperimentalCoroutinesApi::class)
 class SessionExpirationIntegrationTest : KoinTest {
@@ -82,7 +82,7 @@ class SessionExpirationIntegrationTest : KoinTest {
         mockServerScenarioSetup.setScenario(AuthScenario.Success(username = "a", password = "b"), validateArguments = true)
         loginUseCase.invoke(LoginCredentials(username = "a", password = "b"))
         Assertions.assertTrue(isUserLoggedInUseCase.invoke())
-        verifyZeroInteractions(mockSessionExpirationListener)
+        verifyNoInteractions(mockSessionExpirationListener)
 
         mockServerScenarioSetup.setScenario(ContentScenario.Unauthorized(usingRefreshedToken = false))
             .setScenario(RefreshTokenScenario.Error)

core/src/test/java/org/fnives/test/showcase/core/login/IsUserLoggedInUseCaseTest.kt

@@ -8,7 +8,7 @@ import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
 import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.mock
-import org.mockito.kotlin.verifyZeroInteractions
+import org.mockito.kotlin.verifyNoInteractions
 import org.mockito.kotlin.whenever
 
 @Suppress("TestFunctionName")
@@ -26,7 +26,7 @@ internal class IsUserLoggedInUseCaseTest {
     @DisplayName("WHEN nothing is called THEN storage is not called")
     @Test
     fun creatingDoesntAffectStorage() {
-        verifyZeroInteractions(mockUserDataLocalStorage)
+        verifyNoInteractions(mockUserDataLocalStorage)
     }
 
     @DisplayName("GIVEN session data saved WHEN is user logged in checked THEN true is returned")

core/src/test/java/org/fnives/test/showcase/core/login/LoginUseCaseTest.kt

@@ -19,8 +19,8 @@ import org.mockito.kotlin.doThrow
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
+import org.mockito.kotlin.verifyNoInteractions
 import org.mockito.kotlin.verifyNoMoreInteractions
-import org.mockito.kotlin.verifyZeroInteractions
 import org.mockito.kotlin.whenever
 
 @Suppress("TestFunctionName")
@@ -46,8 +46,8 @@ internal class LoginUseCaseTest {
         val actual = sut.invoke(LoginCredentials("", "a"))
 
         Assertions.assertEquals(expected, actual)
-        verifyZeroInteractions(mockLoginRemoteSource)
-        verifyZeroInteractions(mockUserDataLocalStorage)
+        verifyNoInteractions(mockLoginRemoteSource)
+        verifyNoInteractions(mockUserDataLocalStorage)
     }
 
     @DisplayName("GIVEN empty password WHEN trying to login THEN invalid password is returned")
@@ -58,8 +58,8 @@ internal class LoginUseCaseTest {
         val actual = sut.invoke(LoginCredentials("a", ""))
 
         Assertions.assertEquals(expected, actual)
-        verifyZeroInteractions(mockLoginRemoteSource)
-        verifyZeroInteractions(mockUserDataLocalStorage)
+        verifyNoInteractions(mockLoginRemoteSource)
+        verifyNoInteractions(mockUserDataLocalStorage)
     }
 
     @DisplayName("GIVEN invalid credentials response WHEN trying to login THEN invalid credentials is returned ")
@@ -72,7 +72,7 @@ internal class LoginUseCaseTest {
         val actual = sut.invoke(LoginCredentials("a", "b"))
 
         Assertions.assertEquals(expected, actual)
-        verifyZeroInteractions(mockUserDataLocalStorage)
+        verifyNoInteractions(mockUserDataLocalStorage)
     }
 
     @DisplayName("GIVEN success response WHEN trying to login THEN session is saved and success is returned")
@@ -100,6 +100,6 @@ internal class LoginUseCaseTest {
         val actual = sut.invoke(LoginCredentials("a", "b"))
 
         Assertions.assertEquals(expected, actual)
-        verifyZeroInteractions(mockUserDataLocalStorage)
+        verifyNoInteractions(mockUserDataLocalStorage)
     }
 }

core/src/test/java/org/fnives/test/showcase/core/login/LogoutUseCaseTest.kt

@@ -17,8 +17,8 @@ import org.koin.test.KoinTest
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
+import org.mockito.kotlin.verifyNoInteractions
 import org.mockito.kotlin.verifyNoMoreInteractions
-import org.mockito.kotlin.verifyZeroInteractions
 
 @Suppress("TestFunctionName")
 @OptIn(ExperimentalCoroutinesApi::class)
@@ -52,7 +52,7 @@ internal class LogoutUseCaseTest : KoinTest {
     @DisplayName("WHEN no call THEN storage is not interacted")
     @Test
     fun initializedDoesntAffectStorage() {
-        verifyZeroInteractions(mockUserDataLocalStorage)
+        verifyNoInteractions(mockUserDataLocalStorage)
     }
 
     @DisplayName("WHEN logout invoked THEN storage is cleared")

core/src/test/java/org/fnives/test/showcase/core/session/SessionExpirationAdapterTest.kt

@@ -6,8 +6,8 @@ import org.junit.jupiter.api.Test
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
+import org.mockito.kotlin.verifyNoInteractions
 import org.mockito.kotlin.verifyNoMoreInteractions
-import org.mockito.kotlin.verifyZeroInteractions
 
 @Suppress("TestFunctionName")
 internal class SessionExpirationAdapterTest {
@@ -24,7 +24,7 @@ internal class SessionExpirationAdapterTest {
     @DisplayName("WHEN nothing is changed THEN delegate is not touched")
     @Test
     fun verifyNoInteractionsIfNoInvocations() {
-        verifyZeroInteractions(mockSessionExpirationListener)
+        verifyNoInteractions(mockSessionExpirationListener)
     }
 
     @DisplayName("WHEN onSessionExpired is called THEN delegated is also called")

gradlescripts/versions.gradle

@@ -25,7 +25,7 @@ project.ext {
     testing_androidx_junit_version = "1.1.3"
     testing_androidx_arch_core_version = "2.1.0"
     testing_livedata_version = "1.2.0"
-    testing_kotlin_mockito_version = "3.1.0"
+    testing_kotlin_mockito_version = "4.0.0"
     testing_junit5_version = "5.7.0"
     testing_json_assert_version = "1.5.0"
     testing_junit4_version = "4.13.2"

network/src/test/java/org/fnives/test/showcase/network/content/PlainSessionExpirationTest.kt

@@ -25,8 +25,8 @@ import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
+import org.mockito.kotlin.verifyNoInteractions
 import org.mockito.kotlin.verifyNoMoreInteractions
-import org.mockito.kotlin.verifyZeroInteractions
 import org.mockito.kotlin.whenever
 import retrofit2.HttpException
 
@@ -88,7 +88,7 @@ class PlainSessionExpirationTest : KoinTest {
         Assertions.assertEquals("login-access", contentRequestAfterRefreshed.getHeader("Authorization"))
         val expectedSavedSession = Session(accessToken = "login-access", refreshToken = "login-refresh")
         verify(mockNetworkSessionLocalStorage, times(1)).session = expectedSavedSession
-        verifyZeroInteractions(mockNetworkSessionExpirationListener)
+        verifyNoInteractions(mockNetworkSessionExpirationListener)
     }
 
     @DisplayName("GIVEN 401 THEN failing refresh WHEN content requested THE error is returned and callback is Called")

network/src/test/java/org/fnives/test/showcase/network/content/SessionExpirationTest.kt

@@ -27,8 +27,8 @@ import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
+import org.mockito.kotlin.verifyNoInteractions
 import org.mockito.kotlin.verifyNoMoreInteractions
-import org.mockito.kotlin.verifyZeroInteractions
 import org.mockito.kotlin.whenever
 import retrofit2.HttpException
 
@@ -97,7 +97,7 @@ class SessionExpirationTest : KoinTest {
             ContentData.refreshSuccessResponse.accessToken,
             retryAfterTokenRefreshRequest.getHeader("Authorization")
         )
-        verifyZeroInteractions(mockNetworkSessionExpirationListener)
+        verifyNoInteractions(mockNetworkSessionExpirationListener)
     }
 
     @DisplayName("GIVEN 401 THEN failing refresh WHEN content requested THE error is returned and callback is Called")