chore: replace mockito with mockk (part 2) (#18368)

Author: Jonathan Pearlin

airbyte-commons-temporal-core/build.gradle.kts

@@ -22,8 +22,6 @@ dependencies {
   testImplementation(libs.bundles.junit)
   testImplementation(libs.junit.pioneer)
   testImplementation(libs.mockk)
-  testImplementation(libs.mockito.inline)
-  testImplementation(libs.mockito.kotlin)
   testImplementation(libs.temporal.testing)
   // this is temporarily needed because temporal.testing uses InProcessBuilder which is included in on grpc-core 1.52.2
   // featureflag depends on  micronaut-platform 4.4.1 depends on grpc-core 1.62.2, which doesn't contain the InProcessBuilder class.

airbyte-commons-temporal-core/src/test/kotlin/io/airbyte/commons/temporal/WorkflowClientWrappedTest.kt

@@ -7,6 +7,9 @@ package io.airbyte.commons.temporal
 import io.airbyte.metrics.MetricClient
 import io.grpc.Status
 import io.grpc.StatusRuntimeException
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
 import io.temporal.api.workflowservice.v1.DescribeWorkflowExecutionRequest
 import io.temporal.api.workflowservice.v1.DescribeWorkflowExecutionResponse
 import io.temporal.api.workflowservice.v1.WorkflowServiceGrpc.WorkflowServiceBlockingStub
@@ -17,53 +20,43 @@ import io.temporal.serviceclient.WorkflowServiceStubs
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
-import org.mockito.ArgumentMatchers
-import org.mockito.Mockito
-import org.mockito.kotlin.anyOrNull
-import org.mockito.kotlin.anyVararg
 
 internal class WorkflowClientWrappedTest {
   internal class MyWorkflow
 
-  lateinit var metricClient: MetricClient
-  lateinit var temporalWorkflowServiceStubs: WorkflowServiceStubs
-  lateinit var temporalWorkflowServiceBlockingStub: WorkflowServiceBlockingStub
-  lateinit var temporalWorkflowClient: WorkflowClient
-  lateinit var workflowClient: WorkflowClientWrapped
+  private lateinit var metricClient: MetricClient
+  private lateinit var temporalWorkflowServiceStubs: WorkflowServiceStubs
+  private lateinit var temporalWorkflowServiceBlockingStub: WorkflowServiceBlockingStub
+  private lateinit var temporalWorkflowClient: WorkflowClient
+  private lateinit var workflowClient: WorkflowClientWrapped
 
   @BeforeEach
   fun beforeEach() {
-    metricClient = Mockito.mock(MetricClient::class.java)
-    temporalWorkflowServiceBlockingStub = Mockito.mock(WorkflowServiceBlockingStub::class.java)
-    temporalWorkflowServiceStubs = Mockito.mock(WorkflowServiceStubs::class.java)
-    Mockito.`when`(temporalWorkflowServiceStubs.blockingStub()).thenReturn(temporalWorkflowServiceBlockingStub)
-    temporalWorkflowClient = Mockito.mock(WorkflowClient::class.java)
-    Mockito.`when`(temporalWorkflowClient.getWorkflowServiceStubs()).thenReturn(temporalWorkflowServiceStubs)
+    metricClient = mockk(relaxed = true)
+    temporalWorkflowServiceBlockingStub = mockk()
+    temporalWorkflowServiceStubs = mockk()
+    every { temporalWorkflowServiceStubs.blockingStub() } returns temporalWorkflowServiceBlockingStub
+    temporalWorkflowClient = mockk()
+    every { temporalWorkflowClient.workflowServiceStubs } returns temporalWorkflowServiceStubs
     workflowClient =
       WorkflowClientWrapped(temporalWorkflowClient, metricClient, MAX_ATTEMPT, BACKOFF_DELAY_IN_MILLIS, BACKOFF_MAX_DELAY_IN_MILLIS)
   }
 
   @Test
   fun testRetryLogic() {
-    Mockito.`when`(temporalWorkflowClient.newWorkflowStub(ArgumentMatchers.any<Class<Any>>(), ArgumentMatchers.anyString())).thenAnswer {
-      throw
-      unavailable()
-    }
+    every { temporalWorkflowClient.newWorkflowStub(any<Class<Any>>(), any<String>()) } throws unavailable()
 
     Assertions.assertThrows(
       StatusRuntimeException::class.java,
     ) { workflowClient.newWorkflowStub(MyWorkflow::class.java, "fail") }
-    Mockito.verify(temporalWorkflowClient, Mockito.times(3)).newWorkflowStub(ArgumentMatchers.any<Class<Any>>(), ArgumentMatchers.anyString())
-    Mockito.verify(metricClient, Mockito.times(2)).count(anyOrNull(), anyOrNull(), anyVararg())
+    verify(exactly = 3) { temporalWorkflowClient.newWorkflowStub(any<Class<Any>>(), any<String>()) }
+    verify(exactly = 2) { metricClient.count(any(), any(), *anyVararg()) }
   }
 
   @Test
   fun testNewWorkflowStub() {
     val expected = MyWorkflow()
-    Mockito
-      .`when`(temporalWorkflowClient.newWorkflowStub(ArgumentMatchers.any<Class<Any>>(), ArgumentMatchers.anyString()))
-      .thenAnswer { throw unavailable() }
-      .thenReturn(expected)
+    every { temporalWorkflowClient.newWorkflowStub(any<Class<Any>>(), any<String>()) } throws unavailable() andThen expected
 
     val actual = workflowClient.newWorkflowStub(MyWorkflow::class.java, "woot")
     Assertions.assertEquals(expected, actual)
@@ -72,54 +65,43 @@ internal class WorkflowClientWrappedTest {
   @Test
   fun testNewWorkflowStubWithOptions() {
     val expected = MyWorkflow()
-    Mockito
-      .`when`(temporalWorkflowClient.newWorkflowStub(anyOrNull<Class<Any>>(), anyOrNull<WorkflowOptions>()))
-      .thenAnswer { throw unavailable() }
-      .thenReturn(expected)
+    every { temporalWorkflowClient.newWorkflowStub(any<Class<Any>>(), any<WorkflowOptions>()) } throws unavailable() andThen expected
 
     val actual = workflowClient.newWorkflowStub(MyWorkflow::class.java, WorkflowOptions.getDefaultInstance())
     Assertions.assertEquals(expected, actual)
   }
 
   @Test
   fun testTerminateWorkflow() {
-    val workflowStub = Mockito.mock(WorkflowStub::class.java)
-    Mockito
-      .`when`(temporalWorkflowClient.newUntypedWorkflowStub(ArgumentMatchers.anyString()))
-      .thenAnswer { throw unavailable() }
-      .thenReturn(workflowStub)
+    val workflowStub = mockk<WorkflowStub>(relaxed = true)
+    every { temporalWorkflowClient.newUntypedWorkflowStub(any<String>()) } throws unavailable() andThen workflowStub
 
     workflowClient.terminateWorkflow("workflow", "test terminate")
-    Mockito.verify(temporalWorkflowClient, Mockito.times(2)).newUntypedWorkflowStub("workflow")
-    Mockito.verify(workflowStub).terminate("test terminate")
+    verify(exactly = 2) { temporalWorkflowClient.newUntypedWorkflowStub("workflow") }
+    verify { workflowStub.terminate("test terminate") }
   }
 
   @Test
   fun testBlockingDescribeWorkflowExecution() {
-    val expected = Mockito.mock(DescribeWorkflowExecutionResponse::class.java)
-    Mockito
-      .`when`(temporalWorkflowServiceBlockingStub.describeWorkflowExecution(ArgumentMatchers.any()))
-      .thenAnswer { throw unavailable() }
-      .thenReturn(expected)
+    val expected = mockk<DescribeWorkflowExecutionResponse>()
+    every { temporalWorkflowServiceBlockingStub.describeWorkflowExecution(any()) } throws unavailable() andThen expected
 
     val actual =
       workflowClient.blockingDescribeWorkflowExecution(
-        Mockito.mock(
-          DescribeWorkflowExecutionRequest::class.java,
-        ),
+        mockk<DescribeWorkflowExecutionRequest>(),
       )
     Assertions.assertEquals(expected, actual)
   }
 
   @Test
   fun testSignalsAreNotRetried() {
-    Mockito.`when`(temporalWorkflowClient.signalWithStart(ArgumentMatchers.any())).thenAnswer { throw unavailable() }
-    Mockito.`when`(temporalWorkflowClient.newSignalWithStartRequest()).thenReturn(Mockito.mock())
+    every { temporalWorkflowClient.signalWithStart(any()) } throws unavailable()
+    every { temporalWorkflowClient.newSignalWithStartRequest() } returns mockk()
     Assertions.assertThrows(StatusRuntimeException::class.java) {
       val request = workflowClient.newSignalWithStartRequest()
       workflowClient.signalWithStart(request)
     }
-    Mockito.verify(temporalWorkflowClient, Mockito.times(1)).signalWithStart(ArgumentMatchers.any())
+    verify(exactly = 1) { temporalWorkflowClient.signalWithStart(any()) }
   }
 
   companion object {

airbyte-commons-temporal-core/src/test/kotlin/io/airbyte/commons/temporal/WorkflowServiceStubsWrappedTest.kt

@@ -7,6 +7,8 @@ package io.airbyte.commons.temporal
 import io.airbyte.metrics.MetricClient
 import io.grpc.Status
 import io.grpc.StatusRuntimeException
+import io.mockk.every
+import io.mockk.mockk
 import io.temporal.api.workflowservice.v1.ListClosedWorkflowExecutionsRequest
 import io.temporal.api.workflowservice.v1.ListClosedWorkflowExecutionsResponse
 import io.temporal.api.workflowservice.v1.ListOpenWorkflowExecutionsRequest
@@ -16,20 +18,19 @@ import io.temporal.serviceclient.WorkflowServiceStubs
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
-import org.mockito.Mockito
 
 internal class WorkflowServiceStubsWrappedTest {
-  lateinit var metricClient: MetricClient
-  lateinit var temporalWorkflowServiceStubs: WorkflowServiceStubs
-  lateinit var temporalWorkflowServiceBlockingStub: WorkflowServiceBlockingStub
-  lateinit var serviceStubsWrapped: WorkflowServiceStubsWrapped
+  private lateinit var metricClient: MetricClient
+  private lateinit var temporalWorkflowServiceStubs: WorkflowServiceStubs
+  private lateinit var temporalWorkflowServiceBlockingStub: WorkflowServiceBlockingStub
+  private lateinit var serviceStubsWrapped: WorkflowServiceStubsWrapped
 
   @BeforeEach
   fun beforeEach() {
-    metricClient = Mockito.mock(MetricClient::class.java)
-    temporalWorkflowServiceBlockingStub = Mockito.mock(WorkflowServiceBlockingStub::class.java)
-    temporalWorkflowServiceStubs = Mockito.mock(WorkflowServiceStubs::class.java)
-    Mockito.`when`(temporalWorkflowServiceStubs.blockingStub()).thenReturn(temporalWorkflowServiceBlockingStub)
+    metricClient = mockk(relaxed = true)
+    temporalWorkflowServiceBlockingStub = mockk()
+    temporalWorkflowServiceStubs = mockk()
+    every { temporalWorkflowServiceStubs.blockingStub() } returns temporalWorkflowServiceBlockingStub
     serviceStubsWrapped =
       WorkflowServiceStubsWrapped(
         temporalWorkflowServiceStubs,
@@ -44,10 +45,7 @@ internal class WorkflowServiceStubsWrappedTest {
   fun testListClosedWorkflowExecutions() {
     val request = ListClosedWorkflowExecutionsRequest.newBuilder().build()
     val response = ListClosedWorkflowExecutionsResponse.newBuilder().build()
-    Mockito
-      .`when`(temporalWorkflowServiceBlockingStub.listClosedWorkflowExecutions(request))
-      .thenAnswer { throw unavailable() }
-      .thenReturn(response)
+    every { temporalWorkflowServiceBlockingStub.listClosedWorkflowExecutions(request) } throws unavailable() andThen response
 
     val actual = serviceStubsWrapped.blockingStubListClosedWorkflowExecutions(request)
     Assertions.assertEquals(response, actual)
@@ -57,10 +55,7 @@ internal class WorkflowServiceStubsWrappedTest {
   fun testListOpenWorkflowExecutions() {
     val request = ListOpenWorkflowExecutionsRequest.newBuilder().build()
     val response = ListOpenWorkflowExecutionsResponse.newBuilder().build()
-    Mockito
-      .`when`(temporalWorkflowServiceBlockingStub.listOpenWorkflowExecutions(request))
-      .thenAnswer { throw unavailable() }
-      .thenReturn(response)
+    every { temporalWorkflowServiceBlockingStub.listOpenWorkflowExecutions(request) } throws unavailable() andThen response
 
     val actual = serviceStubsWrapped.blockingStubListOpenWorkflowExecutions(request)
     Assertions.assertEquals(response, actual)

airbyte-commons-temporal-core/src/test/kotlin/io/airbyte/commons/temporal/queue/BasicQueueTest.kt

@@ -7,6 +7,10 @@ package io.airbyte.commons.temporal.queue
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize
 import io.airbyte.commons.temporal.WorkflowClientWrapped
 import io.airbyte.metrics.MetricClient
+import io.mockk.mockk
+import io.mockk.slot
+import io.mockk.spyk
+import io.mockk.verify
 import io.temporal.activity.ActivityOptions
 import io.temporal.client.WorkflowClient
 import io.temporal.client.WorkflowOptions
@@ -17,11 +21,6 @@ import org.junit.jupiter.api.AfterAll
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeAll
 import org.junit.jupiter.api.Test
-import org.mockito.ArgumentCaptor
-import org.mockito.ArgumentMatchers.any
-import org.mockito.Mockito.mock
-import org.mockito.Mockito.spy
-import org.mockito.Mockito.verify
 import java.time.Duration
 import java.util.concurrent.CountDownLatch
 
@@ -34,8 +33,10 @@ data class TestQueueInput(
   data class Builder(
     var input: String? = null,
   ) {
+    @Suppress("unused")
     fun input(input: String) = apply { this.input = input }
 
+    @Suppress("unused")
     fun build() = TestQueueInput(input = input!!)
   }
 }
@@ -90,7 +91,7 @@ class BasicQueueTest {
       client = testEnv.workflowClient
 
       consumer = TestConsumer()
-      activity = spy(QueueActivityImpl(consumer))
+      activity = spyk(QueueActivityImpl(consumer))
       worker.registerActivitiesImplementations(activity)
       testEnv.start()
     }
@@ -104,8 +105,8 @@ class BasicQueueTest {
 
   @Test
   fun testRoundTrip() {
-    val workflowClient = spy(WorkflowClientWrapped(client, mock(MetricClient::class.java)))
-    val optionsCaptor = ArgumentCaptor.forClass(WorkflowOptions::class.java)
+    val workflowClient = spyk(WorkflowClientWrapped(client, mockk<MetricClient>(relaxed = true)))
+    val optionsSlot = slot<WorkflowOptions>()
 
     val producer = TemporalMessageProducer<TestQueueInput>(workflowClient)
     val message = TestQueueInput("boom!")
@@ -114,8 +115,8 @@ class BasicQueueTest {
 
     // Since publishing is async, wait on the latch
     consumer.latch.await()
-    verify(activity).consume(Message(message))
-    verify(workflowClient).newWorkflowStub<QueueWorkflow<TestQueueInput>>(any(), optionsCaptor.capture())
-    assertEquals(messageId, optionsCaptor.value.workflowId)
+    verify { activity.consume(Message(message)) }
+    verify { workflowClient.newWorkflowStub<QueueWorkflow<TestQueueInput>>(any(), capture(optionsSlot)) }
+    assertEquals(messageId, optionsSlot.captured.workflowId)
   }
 }

airbyte-connector-rollout-worker/build.gradle.kts

@@ -32,7 +32,6 @@ dependencies {
 
   testImplementation(libs.temporal.testing)
   testImplementation(libs.mockk)
-  testImplementation(libs.mockito.inline)
   testImplementation(libs.bundles.micronaut.test)
 }