KTLN-266: add examples of testing lambda function (#590)

Author: dariusandz

kotlin-testing-2/pom.xml

@@ -14,7 +14,7 @@
     </parent>
 
     <dependencies>
-         <!-- MockK dependencies-->
+        <!-- MockK dependencies-->
         <dependency>
             <groupId>io.mockk</groupId>
             <artifactId>mockk-jvm</artifactId>

kotlin-testing/pom.xml

@@ -14,8 +14,14 @@
     </parent>
 
     <dependencies>
-    <dependency>
-        <groupId>com.nhaarman</groupId>
+        <dependency>
+            <groupId>com.nhaarman</groupId>
+            <artifactId>mockito-kotlin</artifactId>
+            <version>${nhaarman-mockito-kotlin.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito.kotlin</groupId>
             <artifactId>mockito-kotlin</artifactId>
             <version>${mockito-kotlin.version}</version>
             <scope>test</scope>
@@ -48,7 +54,8 @@
     </dependencies>
 
     <properties>
-        <mockito-kotlin.version>1.5.0</mockito-kotlin.version>
+        <nhaarman-mockito-kotlin.version>1.5.0</nhaarman-mockito-kotlin.version>
+        <mockito-kotlin.version>5.1.0</mockito-kotlin.version>
         <spek.version>1.1.5</spek.version>
         <mockk.version>1.9.3</mockk.version>
     </properties>

kotlin-testing/src/test/kotlin/com/baeldung/mockito/argumentcaptor/LambdaCaptorCommandExecutorUnitTest.kt

@@ -0,0 +1,92 @@
+package com.baeldung.mockito.argumentcaptor
+
+import org.junit.jupiter.api.Test
+import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.times
+import org.mockito.kotlin.verify
+
+class CommandExecutor(
+    private val registry: CommandRegistry,
+    private val writer: CommandWriter,
+) {
+    fun executeCommand(command: String) {
+        registry.storeCommand(command) { success ->
+            success && writer.writeCommand(command)
+        }
+    }
+}
+
+interface CommandRegistry {
+    fun storeCommand(command: String, onFinish: (success: Boolean) -> Unit)
+}
+
+interface CommandWriter {
+    fun writeCommand(command: String): Boolean
+}
+
+class CommandExecutorUnitTest {
+
+    @Test
+    fun `when command is executed it is stored in registry`() {
+        // given
+        val command = "CMD_01"
+
+        val registryMock = mock<CommandRegistry>()
+        val commandExecutor = CommandExecutor(registryMock, mock())
+
+        // when
+        commandExecutor.executeCommand(command)
+
+        // then
+        verify(registryMock).storeCommand(eq(command), any())
+    }
+
+    @Test
+    fun `when command is executed and registry max size is not reached it is not dumped to a file`() {
+        // given
+        val command = "CMD_01"
+
+        val registryMock = mock<CommandRegistry>()
+        val writerMock = mock<CommandWriter>()
+        val commandExecutor = CommandExecutor(registryMock, writerMock)
+
+        // when
+        commandExecutor.executeCommand(command)
+
+        // then
+        val captor = argumentCaptor<(Boolean) -> Unit>()
+
+        verify(registryMock).storeCommand(any(), captor.capture())
+
+        val capturedOperation = captor.firstValue
+
+        capturedOperation.invoke(false)
+        verify(writerMock, times(0)).writeCommand(any())
+    }
+
+    @Test
+    fun `when command is executed and registry max size is reached it is dumped to a file`() {
+        // given
+        val command = "CMD_01"
+
+        val registryMock = mock<CommandRegistry>()
+        val writerMock = mock<CommandWriter>()
+        val commandExecutor = CommandExecutor(registryMock, writerMock)
+
+        // when
+        commandExecutor.executeCommand(command)
+
+        // then
+        val captor = argumentCaptor<(Boolean) -> Unit>()
+
+        verify(registryMock).storeCommand(any(), captor.capture())
+
+        val capturedOperation = captor.firstValue
+
+        capturedOperation.invoke(true)
+        verify(writerMock, times(1)).writeCommand(any())
+    }
+}

kotlin-testing/src/test/kotlin/com/baeldung/mockito/argumentcaptor/LambdaCaptorMathOperationUnitTest.kt

@@ -0,0 +1,80 @@
+package com.baeldung.mockito.argumentcaptor
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+
+interface MathOperations {
+    fun performOperation(operation: (a: Int, b: Int) -> Int): Int
+}
+
+class CalculatorService(private val mathOperations: MathOperations) {
+    fun calculate(operation: (a: Int, b: Int) -> Int): Int {
+        return mathOperations.performOperation(operation)
+    }
+}
+
+class CalculatorServiceUnitTest {
+
+    @Test
+    fun `performs addition operation`() {
+        // given
+        val mathOperations = mock<MathOperations>()
+        val calculatorService = CalculatorService(mathOperations)
+
+        // when
+        calculatorService.calculate { a, b -> a + b }
+
+        // then
+        val lambdaCaptor = argumentCaptor<(Int, Int) -> Int>()
+
+        verify(mathOperations).performOperation(lambdaCaptor.capture())
+
+        val capturedOperation = lambdaCaptor.firstValue
+        val operationResult = capturedOperation(11, 3)
+
+        assertEquals(14, operationResult)
+    }
+
+    @Test
+    fun `performs subtraction operation`() {
+        // given
+        val mathOperations = mock<MathOperations>()
+        val calculatorService = CalculatorService(mathOperations)
+
+        // when
+        calculatorService.calculate { a, b -> a - b }
+
+        // then
+        val lambdaCaptor = argumentCaptor<(Int, Int) -> Int>()
+
+        verify(mathOperations).performOperation(lambdaCaptor.capture())
+
+        val capturedOperation = lambdaCaptor.firstValue
+        val operationResult = capturedOperation(11, 3)
+
+        assertEquals(8, operationResult)
+    }
+
+    @Test
+    fun `performs multiplication operation`() {
+        // given
+        val mathOperations = mock<MathOperations>()
+        val calculatorService = CalculatorService(mathOperations)
+
+        // when
+        calculatorService.calculate { a, b -> a * b }
+
+        // then
+        val lambdaCaptor = argumentCaptor<(Int, Int) -> Int>()
+
+        verify(mathOperations).performOperation(lambdaCaptor.capture())
+
+        val capturedOperation = lambdaCaptor.firstValue
+        val operationResult = capturedOperation(11, 3)
+
+        assertEquals(33, operationResult)
+    }
+}