[mockito.kotlin → mockk] Migrated intellij.vcs.github tests from mockito.kotlin to mockk

GitOrigin-RevId: 32df0857285bf8d5dd7f4182bdc740eebfc2e46c

plugins/github/intellij.vcs.github.iml

@@ -79,8 +79,8 @@
     <orderEntry type="library" scope="PROVIDED" name="kotlinc.kotlinx-serialization-compiler-plugin" level="project" />
     <orderEntry type="module" module-name="intellij.platform.util.coroutines" />
     <orderEntry type="library" scope="TEST" name="JUnit4" level="project" />
-    <orderEntry type="library" scope="TEST" name="mockito" level="project" />
-    <orderEntry type="library" scope="TEST" name="mockito.kotlin" level="project" />
     <orderEntry type="library" scope="TEST" name="kotlinx-coroutines-test" level="project" />
+    <orderEntry type="library" scope="TEST" name="io.mockk" level="project" />
+    <orderEntry type="library" scope="TEST" name="io.mockk.jvm" level="project" />
   </component>
 </module>

plugins/github/test/org/jetbrains/plugins/github/pullrequest/data/provider/GHPRChangesDataProviderImplTest.kt

@@ -6,6 +6,7 @@ import com.intellij.collaboration.util.ComputedResult
 import com.intellij.collaboration.util.FlowTestUtil.assertEmits
 import com.intellij.collaboration.util.MainDispatcherRule
 import git4idea.changes.GitBranchComparisonResult
+import io.mockk.*
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.test.TestScope
@@ -18,12 +19,7 @@ import org.jetbrains.plugins.github.pullrequest.data.GHPRIdentifier
 import org.jetbrains.plugins.github.pullrequest.data.service.GHPRChangesService
 import org.junit.Assert.assertEquals
 import org.junit.ClassRule
-import org.junit.Rule
 import org.junit.Test
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnit
-import org.mockito.junit.MockitoRule
-import org.mockito.kotlin.*
 import java.util.*
 import kotlin.time.Duration.Companion.seconds
 
@@ -37,12 +33,7 @@ class GHPRChangesDataProviderImplTest {
     internal val mainRule = MainDispatcherRule()
   }
 
-  @Rule
-  @JvmField
-  internal val mockitoRule: MockitoRule = MockitoJUnit.rule()
-
-  @Mock
-  internal lateinit var changesService: GHPRChangesService
+  private val changesService = mockk<GHPRChangesService>()
 
   private fun TestScope.createProvider(refs: GHPRBranchesRefs): GHPRChangesDataProvider =
     GHPRChangesDataProviderImpl(backgroundScope, changesService, { refs }, PR_ID)
@@ -52,18 +43,19 @@ class GHPRChangesDataProviderImplTest {
     val refs = GHPRBranchesRefs("b", "h")
     val mergeBaseRef = "mb"
 
-    val result = mock<GitBranchComparisonResult>()
-    whenever(changesService.loadCommitsFromApi(PR_ID)) doReturn createMockCommits(refs.headRef)
-    whenever(changesService.loadMergeBaseOid(any(), any())) doReturn mergeBaseRef
-    whenever(changesService.createChangesProvider(eq(PR_ID), any(), any(), any(), any())) doReturn result
-
+    val result = mockk<GitBranchComparisonResult>()
+    coEvery { changesService.loadCommitsFromApi(PR_ID) } returns createMockCommits(refs.headRef)
+    coEvery { changesService.loadMergeBaseOid(any(), any()) } returns mergeBaseRef
+    coEvery { changesService.createChangesProvider(eq(PR_ID), any(), any(), any(), any()) } returns result
 
     val inst = createProvider(refs)
     assertEquals(inst.loadChanges(), inst.loadChanges())
     assertEquals(inst.loadCommits(), inst.loadCommits())
 
-    verify(changesService, times(1)).loadCommitsFromApi(eq(PR_ID))
-    verify(changesService, times(1)).createChangesProvider(eq(PR_ID), eq(refs.baseRef), eq(mergeBaseRef), eq(refs.headRef), any())
+    coVerify(exactly = 1) {
+      changesService.loadCommitsFromApi(eq(PR_ID))
+      changesService.createChangesProvider(eq(PR_ID), eq(refs.baseRef), eq(mergeBaseRef), eq(refs.headRef), any())
+    }
   }
 
   @OptIn(ExperimentalCoroutinesApi::class)
@@ -72,12 +64,12 @@ class GHPRChangesDataProviderImplTest {
     val refs = GHPRBranchesRefs("b", "h")
     val mergeBaseRef = "mb"
 
-    whenever(changesService.loadCommitsFromApi(PR_ID)) doReturn createMockCommits(refs.headRef)
-    whenever(changesService.loadMergeBaseOid(any(), any())) doReturn mergeBaseRef
+    coEvery { changesService.loadCommitsFromApi(PR_ID) } returns createMockCommits(refs.headRef)
+    coEvery { changesService.loadMergeBaseOid(any(), any()) } returns mergeBaseRef
 
-    val result = mock<GitBranchComparisonResult>()
+    val result = mockk<GitBranchComparisonResult>()
     var counter = 0
-    whenever(changesService.createChangesProvider(eq(PR_ID), any(), any(), any(), any())) doSuspendableAnswer {
+    coEvery { changesService.createChangesProvider(eq(PR_ID), any(), any(), any(), any()) } coAnswers {
       if (counter == 0) {
         delay(1.seconds)
         throw EXCEPTION
@@ -117,8 +109,8 @@ private fun createMockCommits(headRef: String): List<GHCommit> {
       url = "mockUrl$i",
       messageHeadline = "Mock Commit Headline $i",
       messageBody = "Mock Commit Body $i",
-      author = mock(),
-      committer = mock(),
+      author = mockk(),
+      committer = mockk(),
       committedDate = Date(),
       parents = mockParents
     )

plugins/github/test/org/jetbrains/plugins/github/pullrequest/data/provider/GHPRCommentsDataProviderImplTest.kt

@@ -2,18 +2,13 @@ package org.jetbrains.plugins.github.pullrequest.data.provider
 
 import com.intellij.collaboration.util.MainDispatcherRule
 import com.intellij.util.messages.MessageBus
+import io.mockk.*
 import kotlinx.coroutines.test.runTest
 import org.jetbrains.plugins.github.api.data.GHComment
 import org.jetbrains.plugins.github.pullrequest.data.GHPRIdentifier
 import org.jetbrains.plugins.github.pullrequest.data.service.GHPRCommentService
-import org.junit.Before
 import org.junit.ClassRule
-import org.junit.Rule
 import org.junit.Test
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnit
-import org.mockito.junit.MockitoRule
-import org.mockito.kotlin.*
 import java.util.*
 
 class GHPRCommentsDataProviderImplTest {
@@ -25,35 +20,25 @@ class GHPRCommentsDataProviderImplTest {
     internal val mainRule = MainDispatcherRule()
   }
 
-  @Rule
-  @JvmField
-  internal val mockitoRule: MockitoRule = MockitoJUnit.rule()
-
-  @Mock
-  internal lateinit var commentsService: GHPRCommentService
-
-  @Mock
-  internal lateinit var messageBus: MessageBus
-
-  @Mock
-  internal lateinit var listener: GHPRDataOperationsListener
+  private val commentsService = mockk<GHPRCommentService>(relaxed = true)
+  private val listener = mockk<GHPRDataOperationsListener>(relaxUnitFun = true)
+  private val messageBus = mockk<MessageBus> {
+    every { syncPublisher(GHPRDataOperationsListener.TOPIC) } returns listener
+  }
 
   private fun createProvider(): GHPRCommentsDataProvider =
     GHPRCommentsDataProviderImpl(commentsService, PR_ID, messageBus)
 
-  @Before
-  fun setUp() {
-    whenever(messageBus.syncPublisher(GHPRDataOperationsListener.TOPIC)) doReturn listener
-  }
-
   @Test
   fun testAddComment() = runTest {
     val body = "test"
 
     val prv = createProvider()
     prv.addComment(body)
-    verify(commentsService, times(1)).addComment(eq(PR_ID), eq(body))
-    verify(listener, times(1)).onCommentAdded()
+    coVerifyAll {
+      commentsService.addComment(eq(PR_ID), eq(body))
+      listener.onCommentAdded()
+    }
   }
 
   @Test
@@ -61,12 +46,14 @@ class GHPRCommentsDataProviderImplTest {
     val id = "id"
     val body = "test"
 
-    whenever(commentsService.updateComment(eq(id), any())) doReturn GHComment("", null, body, Date(), mock())
+    coEvery { commentsService.updateComment(eq(id), any()) } returns GHComment("", null, body, Date(), mockk())
 
     val prv = createProvider()
     prv.updateComment(id, body)
-    verify(commentsService, times(1)).updateComment(eq(id), eq(body))
-    verify(listener, times(1)).onCommentUpdated(eq(id), eq(body))
+    coVerifyAll {
+      commentsService.updateComment(eq(id), eq(body))
+      listener.onCommentUpdated(eq(id), eq(body))
+    }
   }
 
   @Test
@@ -74,7 +61,9 @@ class GHPRCommentsDataProviderImplTest {
     val id = "id"
     val prv = createProvider()
     prv.deleteComment(id)
-    verify(commentsService, times(1)).deleteComment(eq(id))
-    verify(listener, times(1)).onCommentDeleted(eq(id))
+    coVerifyAll {
+      commentsService.deleteComment(eq(id))
+      listener.onCommentDeleted(eq(id))
+    }
   }
-}
+}

plugins/github/test/org/jetbrains/plugins/github/pullrequest/data/provider/GHPRDetailsDataProviderImplTest.kt

@@ -5,6 +5,10 @@ import com.intellij.collaboration.util.ComputedResult
 import com.intellij.collaboration.util.FlowTestUtil.assertEmits
 import com.intellij.collaboration.util.MainDispatcherRule
 import com.intellij.util.messages.MessageBus
+import io.mockk.coEvery
+import io.mockk.coVerifyAll
+import io.mockk.every
+import io.mockk.mockk
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.test.TestScope
@@ -16,16 +20,10 @@ import org.jetbrains.plugins.github.pullrequest.data.GHPRIdentifier
 import org.jetbrains.plugins.github.pullrequest.data.GHPRMergeabilityState
 import org.jetbrains.plugins.github.pullrequest.data.service.GHPRDetailsService
 import org.junit.Assert.assertEquals
-import org.junit.Before
 import org.junit.ClassRule
-import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnit
-import org.mockito.junit.MockitoRule
-import org.mockito.kotlin.*
 import kotlin.time.Duration.Companion.seconds
 
 private val PR_ID = GHPRIdentifier("id", 0)
@@ -40,30 +38,18 @@ class GHPRDetailsDataProviderImplTest {
     internal val mainRule = MainDispatcherRule()
   }
 
-  @Rule
-  @JvmField
-  internal val mockitoRule: MockitoRule = MockitoJUnit.rule()
-
-  @Mock
-  internal lateinit var detailsService: GHPRDetailsService
-
-  @Mock
-  internal lateinit var messageBus: MessageBus
-
-  @Mock
-  internal lateinit var listener: GHPRDataOperationsListener
-
-  @Before
-  internal fun setup() {
-    whenever(messageBus.syncPublisher(GHPRDataOperationsListener.TOPIC)) doReturn listener
+  private val detailsService = mockk<GHPRDetailsService>(relaxUnitFun = true)
+  private val listener = mockk<GHPRDataOperationsListener>(relaxUnitFun = true)
+  private val messageBus = mockk<MessageBus> {
+    every { syncPublisher(GHPRDataOperationsListener.TOPIC) } returns listener
   }
 
   private fun TestScope.createProvider() = GHPRDetailsDataProviderImpl(backgroundScope, detailsService, PR_ID, messageBus)
 
   @Test
   fun testCachingDetailsLoad() = runTest {
-    val result = mock<GHPullRequest>()
-    whenever(detailsService.loadDetails(PR_ID)) doReturn result
+    val result = mockk<GHPullRequest>()
+    coEvery { detailsService.loadDetails(PR_ID) } returns result
 
     val inst = createProvider()
     assertEquals(inst.loadDetails(), result)
@@ -71,12 +57,14 @@ class GHPRDetailsDataProviderImplTest {
     assertEquals(inst.loadDetails(), result)
     assertEquals(inst.loadedDetails, result)
 
-    verify(detailsService, times(1)).loadDetails(PR_ID)
+    coVerifyAll {
+      detailsService.loadDetails(PR_ID)
+    }
   }
 
   @Test
   fun testDetailsErrorLoad() = runTest {
-    whenever(detailsService.loadDetails(PR_ID)) doThrow EXCEPTION
+    coEvery { detailsService.loadDetails(PR_ID) } throws EXCEPTION
 
     val inst = createProvider()
     runCatching {
@@ -85,14 +73,14 @@ class GHPRDetailsDataProviderImplTest {
       assertEquals(EXCEPTION, exceptionOrNull())
     }
 
-    verify(detailsService, times(1)).loadDetails(PR_ID)
+    coVerifyAll { detailsService.loadDetails(PR_ID) }
   }
 
   @Test
   fun testDetailsReloadAfterError() = runTest {
-    val result = mock<GHPullRequest>()
+    val result = mockk<GHPullRequest>()
     var counter = 0
-    whenever(detailsService.loadDetails(PR_ID)) doSuspendableAnswer {
+    coEvery { detailsService.loadDetails(PR_ID) } coAnswers {
       if (counter == 0) {
         throw EXCEPTION
       }
@@ -107,41 +95,46 @@ class GHPRDetailsDataProviderImplTest {
     inst.signalDetailsNeedReload()
     runCatching { inst.loadDetails() }.apply { assertEquals(result, getOrThrow()) }
 
-    verify(detailsService, times(2)).loadDetails(PR_ID)
+    coVerifyAll {
+      detailsService.loadDetails(PR_ID)
+      detailsService.loadDetails(PR_ID)
+    }
   }
 
   @Test
   fun testUpdate() = runTest {
-    val result1 = mock<GHPullRequest>()
-    val result2 = mock<GHPullRequest>()
-    whenever(detailsService.loadDetails(PR_ID)) doReturn result1
-    whenever(detailsService.updateDetails(eq(PR_ID), any(), any())) doReturn result2
+    val result1 = mockk<GHPullRequest>()
+    val result2 = mockk<GHPullRequest>()
+    coEvery { detailsService.loadDetails(PR_ID) } returns result1
+    coEvery { detailsService.updateDetails(eq(PR_ID), any(), any()) } returns result2
 
     val inst = createProvider()
     assertEquals(inst.loadDetails(), result1)
     inst.updateDetails("", "")
     assertEquals(inst.loadDetails(), result2)
 
-    verify(detailsService, times(1)).updateDetails(eq(PR_ID), any(), any())
-    verify(detailsService, times(1)).loadDetails(PR_ID)
-    verify(listener, times(1)).onMetadataChanged()
+    coVerifyAll {
+      detailsService.updateDetails(eq(PR_ID), any(), any())
+      detailsService.loadDetails(PR_ID)
+      listener.onMetadataChanged()
+    }
   }
 
   @Test
   fun testCachingMergeabilityLoad() = runTest {
-    val result = mock<GHPRMergeabilityState>()
-    whenever(detailsService.loadMergeabilityState(PR_ID)) doReturn result
+    val result = mockk<GHPRMergeabilityState>()
+    coEvery { detailsService.loadMergeabilityState(PR_ID) } returns result
 
     val inst = createProvider()
     assertEquals(inst.loadMergeabilityState(), result)
     assertEquals(inst.loadMergeabilityState(), result)
 
-    verify(detailsService, times(1)).loadMergeabilityState(PR_ID)
+    coVerifyAll { detailsService.loadMergeabilityState(PR_ID) }
   }
 
   @Test
   fun testMergeabilityErrorLoad() = runTest {
-    whenever(detailsService.loadMergeabilityState(PR_ID)) doThrow EXCEPTION
+    coEvery { detailsService.loadMergeabilityState(PR_ID) } throws EXCEPTION
 
     val inst = createProvider()
     runCatching {
@@ -150,14 +143,14 @@ class GHPRDetailsDataProviderImplTest {
       assertEquals(EXCEPTION, exceptionOrNull())
     }
 
-    verify(detailsService, times(1)).loadMergeabilityState(PR_ID)
+    coVerifyAll { detailsService.loadMergeabilityState(PR_ID) }
   }
 
   @Test
   fun testMergeabilityReloadAfterError() = runTest {
-    val result = mock<GHPRMergeabilityState>()
+    val result = mockk<GHPRMergeabilityState>()
     var counter = 0
-    whenever(detailsService.loadMergeabilityState(PR_ID)) doSuspendableAnswer {
+    coEvery { detailsService.loadMergeabilityState(PR_ID) } coAnswers {
       if (counter == 0) {
         throw EXCEPTION
       }
@@ -172,17 +165,21 @@ class GHPRDetailsDataProviderImplTest {
     inst.signalMergeabilityNeedsReload()
     runCatching { inst.loadMergeabilityState() }.apply { assertEquals(result, getOrThrow()) }
 
-    verify(detailsService, times(2)).loadMergeabilityState(PR_ID)
+    coVerifyAll {
+      detailsService.loadMergeabilityState(PR_ID)
+      detailsService.loadMergeabilityState(PR_ID)
+    }
   }
 
   @Test
   fun testReviewers() = runTest {
     val inst = createProvider()
-    inst.adjustReviewers(mock())
+    inst.adjustReviewers(mockk())
 
-    verify(detailsService, never()).loadDetails(PR_ID)
-    verify(detailsService, times(1)).adjustReviewers(eq(PR_ID), any())
-    verify(listener, times(1)).onMetadataChanged()
+    coVerifyAll {
+      detailsService.adjustReviewers(eq(PR_ID), any())
+      listener.onMetadataChanged()
+    }
   }
 
   @Test
@@ -190,17 +187,18 @@ class GHPRDetailsDataProviderImplTest {
     val inst = createProvider()
     inst.close()
 
-    verify(detailsService, never()).loadDetails(PR_ID)
-    verify(detailsService, times(1)).close(PR_ID)
-    verify(listener, times(1)).onMetadataChanged()
+    coVerifyAll {
+      detailsService.close(eq(PR_ID))
+      listener.onMetadataChanged()
+    }
   }
 
   @OptIn(ExperimentalCoroutinesApi::class)
   @Test
   fun testDetailsFlow() = runTest(UnconfinedTestDispatcher()) {
-    val result = mock<GHPullRequest>()
+    val result = mockk<GHPullRequest>()
     var counter = 0
-    whenever(detailsService.loadDetails(PR_ID)) doSuspendableAnswer {
+    coEvery { detailsService.loadDetails(PR_ID) } coAnswers {
       if (counter == 0) {
         delay(1.seconds)
         throw EXCEPTION
@@ -225,9 +223,9 @@ class GHPRDetailsDataProviderImplTest {
   @OptIn(ExperimentalCoroutinesApi::class)
   @Test
   fun testMergeabilityFlow() = runTest(UnconfinedTestDispatcher()) {
-    val result = mock<GHPRMergeabilityState>()
+    val result = mockk<GHPRMergeabilityState>()
     var counter = 0
-    whenever(detailsService.loadMergeabilityState(PR_ID)) doSuspendableAnswer {
+    coEvery { detailsService.loadMergeabilityState(PR_ID) } coAnswers {
       if (counter == 0) {
         delay(1.seconds)
         throw EXCEPTION

plugins/github/test/org/jetbrains/plugins/github/pullrequest/data/provider/GHPRReviewDataProviderImplTest.kt

@@ -4,6 +4,7 @@ package org.jetbrains.plugins.github.pullrequest.data.provider
 import com.intellij.collaboration.api.dto.GraphQLNodesDTO
 import com.intellij.collaboration.util.MainDispatcherRule
 import com.intellij.util.messages.MessageBus
+import io.mockk.*
 import kotlinx.coroutines.test.TestScope
 import kotlinx.coroutines.test.runTest
 import org.jetbrains.plugins.github.api.data.pullrequest.GHPullRequestPendingReviewDTO
@@ -13,16 +14,10 @@ import org.jetbrains.plugins.github.api.data.pullrequest.GHPullRequestReviewThre
 import org.jetbrains.plugins.github.pullrequest.data.GHPRIdentifier
 import org.jetbrains.plugins.github.pullrequest.data.service.GHPRReviewService
 import org.junit.Assert.assertEquals
-import org.junit.Before
 import org.junit.ClassRule
-import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnit
-import org.mockito.junit.MockitoRule
-import org.mockito.kotlin.*
 
 private val PR_ID = GHPRIdentifier("id", 0)
 
@@ -36,74 +31,64 @@ class GHPRReviewDataProviderImplTest {
     internal val mainRule = MainDispatcherRule()
   }
 
-  @Rule
-  @JvmField
-  internal val mockitoRule: MockitoRule = MockitoJUnit.rule()
-
-  @Mock
-  internal lateinit var reviewService: GHPRReviewService
-
-  @Mock
-  internal lateinit var messageBus: MessageBus
-
-  @Mock
-  internal lateinit var listener: GHPRDataOperationsListener
+  private val reviewService = mockk<GHPRReviewService>(relaxUnitFun = true)
+  private val listener = mockk<GHPRDataOperationsListener>(relaxUnitFun = true)
+  private val messageBus = mockk<MessageBus> {
+    every { syncPublisher(GHPRDataOperationsListener.TOPIC) } returns listener
+  }
 
   private fun TestScope.createProvider(): GHPRReviewDataProvider =
-    GHPRReviewDataProviderImpl(backgroundScope, reviewService, mock(), PR_ID, messageBus)
+    GHPRReviewDataProviderImpl(backgroundScope, reviewService, mockk(), PR_ID, messageBus)
 
   private fun createPendingReview(id: String, comments: List<GHPullRequestReviewComment>): GHPullRequestPendingReviewDTO =
     GHPullRequestPendingReviewDTO(id, GHPullRequestReviewState.PENDING, GraphQLNodesDTO(comments, comments.size))
 
-  @Before
-  fun setUp() {
-    whenever(messageBus.syncPublisher(GHPRDataOperationsListener.TOPIC)) doReturn listener
-  }
-
   @Test
   fun testCachingReviewLoad() = runTest {
-    whenever(reviewService.loadPendingReview(PR_ID)) doReturn createPendingReview("", listOf(mock()))
+    coEvery { reviewService.loadPendingReview(eq(PR_ID)) } returns createPendingReview("", listOf(mockk()))
 
     val prv = createProvider()
     val result = prv.loadPendingReview()
     assertEquals(prv.loadPendingReview(), result)
 
-    verify(reviewService, times(1)).loadPendingReview(PR_ID)
+    coVerifyAll { reviewService.loadPendingReview(PR_ID) }
   }
 
   @Test
   fun testCreateAndSubmitReview() = runTest {
-    whenever(reviewService.loadPendingReview(eq(PR_ID))) doReturn null
-    whenever(reviewService.createReview(eq(PR_ID), anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull())) doReturn
-      createPendingReview("", listOf(mock()))
+    coEvery { reviewService.loadPendingReview(eq(PR_ID)) } returns null
+    coEvery { reviewService.createReview(eq(PR_ID), any(), any(), any(), any()) } returns createPendingReview("", listOf(mockk()))
 
     val prv = createProvider()
-    prv.createReview(mock(), "test")
-    verify(reviewService, times(1)).createReview(eq(PR_ID), anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull())
+    prv.createReview(mockk(), "test")
+    coVerify { reviewService.createReview(eq(PR_ID), any(), any(), any(), any()) }
 
     assertEquals(prv.loadPendingReview(), null)
-    verify(reviewService, times(1)).loadPendingReview(PR_ID)
+    coVerify { reviewService.loadPendingReview(PR_ID) }
+    confirmVerified(reviewService)
   }
 
   @Test
   fun testCreatePendingReviewImmediateUpdate() = runTest {
-    val result = createPendingReview("", listOf(mock()))
-    whenever(reviewService.createReview(eq(PR_ID), anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull())) doReturn result
+    val result = createPendingReview("", listOf(mockk()))
+    coEvery { reviewService.createReview(eq(PR_ID), any(), any(), any(), any()) } returns result
 
     val prv = createProvider()
     prv.createReview(null, "test")
-    verify(reviewService, times(1)).createReview(eq(PR_ID), anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull())
-    verify(listener, times(1)).onReviewsChanged()
+    coVerifyAll {
+      reviewService.createReview(eq(PR_ID), any(), any(), any(), any())
+      listener.onReviewsChanged()
+    }
 
     assertEquals(result.toModel(), prv.loadPendingReview())
-    verify(reviewService, never()).loadPendingReview(PR_ID)
+    confirmVerified(reviewService)
   }
 
   @Test
   fun testDeleteReviewUpdatedImmediately() = runTest {
-    val reviewDto = createPendingReview("REVIEW", listOf(mock()))
+    val reviewDto = createPendingReview("REVIEW", listOf(mockk()))
 
-    whenever(reviewService.loadPendingReview(eq(PR_ID))) doReturn reviewDto
+    coEvery { reviewService.loadPendingReview(eq(PR_ID)) } returns reviewDto
 
     val prv = createProvider()
     // fill cache
@@ -111,9 +96,11 @@ class GHPRReviewDataProviderImplTest {
     prv.deleteReview(reviewDto.id)
     assertEquals(null, prv.loadPendingReview())
 
-    verify(reviewService, times(1)).loadPendingReview(eq(PR_ID))
-    verify(reviewService, times(1)).deleteReview(eq(PR_ID), eq(reviewDto.id))
-    verify(listener, times(1)).onReviewsChanged()
+    coVerifySequence {
+      reviewService.loadPendingReview(eq(PR_ID))
+      reviewService.deleteReview(eq(PR_ID), eq(reviewDto.id))
+      listener.onReviewsChanged()
+    }
   }
 
   @Test
@@ -121,24 +108,26 @@ class GHPRReviewDataProviderImplTest {
     val reviewId = "REVIEW"
     val text = "test"
 
-    whenever(reviewService.updateReviewBody(eq(reviewId), eq(text))) doReturn mock()
+    coEvery { reviewService.updateReviewBody(eq(reviewId), eq(text)) } returns mockk(relaxed = true)
 
     val prv = createProvider()
     prv.updateReviewBody(reviewId, text)
 
-    verify(reviewService, times(1)).updateReviewBody(eq(reviewId), eq(text))
-    verify(listener, times(1)).onReviewUpdated(eq(reviewId), eq(text))
+    coVerifySequence {
+      reviewService.updateReviewBody(eq(reviewId), eq(text))
+      listener.onReviewUpdated(eq(reviewId), eq(text))
+    }
   }
 
   @Test
   fun testCachingThreadsLoad() = runTest {
-    val result = mock<List<GHPullRequestReviewThread>>()
-    whenever(reviewService.loadReviewThreads(PR_ID)) doReturn result
+    val result = mockk<List<GHPullRequestReviewThread>>()
+    coEvery { reviewService.loadReviewThreads(PR_ID) } returns result
 
     val prv = createProvider()
     assertEquals(prv.loadThreads(), result)
     assertEquals(prv.loadThreads(), result)
 
-    verify(reviewService, times(1)).loadReviewThreads(PR_ID)
+    coVerifyAll { reviewService.loadReviewThreads(PR_ID) }
   }
 }

plugins/github/test/org/jetbrains/plugins/github/pullrequest/data/provider/GHPRViewedStateDataProviderImplTest.kt

@@ -4,6 +4,10 @@ import com.intellij.collaboration.async.launchNow
 import com.intellij.collaboration.util.ComputedResult
 import com.intellij.collaboration.util.FlowTestUtil.assertEmits
 import com.intellij.collaboration.util.MainDispatcherRule
+import io.mockk.coEvery
+import io.mockk.coVerify
+import io.mockk.coVerifyAll
+import io.mockk.mockk
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.first
@@ -17,12 +21,7 @@ import org.jetbrains.plugins.github.pullrequest.data.GHPRIdentifier
 import org.jetbrains.plugins.github.pullrequest.data.service.GHPRFilesService
 import org.junit.Assert.assertEquals
 import org.junit.ClassRule
-import org.junit.Rule
 import org.junit.Test
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnit
-import org.mockito.junit.MockitoRule
-import org.mockito.kotlin.*
 import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.Duration.Companion.seconds
 
@@ -36,12 +35,7 @@ class GHPRViewedStateDataProviderImplTest {
     internal val mainRule = MainDispatcherRule()
   }
 
-  @Rule
-  @JvmField
-  internal val mockitoRule: MockitoRule = MockitoJUnit.rule()
-
-  @Mock
-  internal lateinit var filesService: GHPRFilesService
+  private val filesService = mockk<GHPRFilesService>()
 
   private fun TestScope.createProvider(): GHPRViewedStateDataProvider =
     GHPRViewedStateDataProviderImpl(backgroundScope, filesService, PR_ID)
@@ -49,17 +43,17 @@ class GHPRViewedStateDataProviderImplTest {
   @Test
   fun testCachingStateLoad() = runTest {
     val result = emptyList<GHPullRequestChangedFile>()
-    whenever(filesService.loadFiles(PR_ID)) doReturn result
+    coEvery { filesService.loadFiles(PR_ID) } returns result
 
     val inst = createProvider()
     assertEquals(inst.loadViewedState(), inst.loadViewedState())
 
-    verify(filesService, times(1)).loadFiles(eq(PR_ID))
+    coVerifyAll { filesService.loadFiles(eq(PR_ID)) }
   }
 
   @Test
   fun testReloadOnError() = runTest {
-    whenever(filesService.updateViewedState(eq(PR_ID), any(), any())) doThrow EXCEPTION
+    coEvery { filesService.updateViewedState(eq(PR_ID), any(), any()) } throws EXCEPTION
 
     val inst = createProvider()
     val signalAwaiter = launchNow {
@@ -71,7 +65,7 @@ class GHPRViewedStateDataProviderImplTest {
       signalAwaiter.join()
     }
 
-    verify(filesService, atLeastOnce()).updateViewedState(eq(PR_ID), any(), any())
+    coVerify { filesService.updateViewedState(eq(PR_ID), any(), any()) }
   }
 
   @OptIn(ExperimentalCoroutinesApi::class)
@@ -79,7 +73,7 @@ class GHPRViewedStateDataProviderImplTest {
   fun testChangesFlow() = runTest(UnconfinedTestDispatcher()) {
     val result = emptyList<GHPullRequestChangedFile>()
     var counter = 0
-    whenever(filesService.loadFiles(eq(PR_ID))) doSuspendableAnswer {
+    coEvery { filesService.loadFiles(eq(PR_ID)) } coAnswers {
       if (counter == 0) {
         delay(1.seconds)
         throw EXCEPTION