Improve testing

src/test/kotlin/data/mappers/MapperKtTest.kt

@@ -312,4 +312,41 @@ class MapperKtTest {
         )
         assertEquals(TASK, taskAuditLog.toDto().auditType)
     }
+
+    @Test
+    fun `test String to SubTask conversion`() {
+        val uuidString = "550e8400-e29b-41d4-a716-446655440000"
+
+        val subTask = uuidString.toSubTask()
+
+        assertEquals(UUID.fromString(uuidString), subTask.id)
+        assertEquals("", subTask.title)
+        assertEquals("", subTask.description)
+        assertEquals(false, subTask.isCompleted)
+        assertEquals(UUID.fromString(uuidString), subTask.parentTaskId)
+    }
+
+    @Test
+    fun `test TaskDto to Task conversion with subTasks`() {
+        val taskDto = TaskDto(
+            id = "550e8400-e29b-41d4-a716-446655440000",
+            name = "Test Task",
+            description = "Task Description",
+            projectId = "550e8400-e29b-41d4-a716-446655440001",
+            stateId = "550e8400-e29b-41d4-a716-446655440002",
+            subTasks = listOf("550e8400-e29b-41d4-a716-446655440003")
+        )
+
+        val task = taskDto.toTask()
+
+        assertEquals(UUID.fromString("550e8400-e29b-41d4-a716-446655440000"), task.id)
+        assertEquals("Test Task", task.title)
+        assertEquals("Task Description", task.description)
+        assertEquals(1, task.subTasks.size)
+        val subTask = task.subTasks[0]
+        assertEquals(UUID.fromString("550e8400-e29b-41d4-a716-446655440003"), subTask.id)
+        assertEquals("", subTask.title)
+        assertEquals(false, subTask.isCompleted)
+    }
+
 }

src/test/kotlin/data/repositories/TaskStateDataSourceImplTest.kt → src/test/kotlin/data/repositories/TaskStateRepositoryImplTest.kt

@@ -17,7 +17,7 @@ import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
 import java.util.*
 
-class TaskStateDataSourceImplTest {
+class TaskStateRepositoryImplTest {
 
     private lateinit var dataSource: TaskDataSource
     private lateinit var repository: TasksRepositoryImpl

src/test/kotlin/domain/usecases/sub_task/CreateSubTaskUseCaseTest.kt

@@ -0,0 +1,91 @@
+package domain.usecases.sub_task
+
+import domain.models.SubTask
+import domain.repositories.SubTaskRepository
+import io.mockk.coEvery
+import io.mockk.coVerify
+import io.mockk.mockk
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import java.util.*
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class CreateSubTaskUseCaseTest {
+    private lateinit var createSubTaskUseCase: CreateSubTaskUseCase
+    private lateinit var subTaskRepository: SubTaskRepository
+
+    @BeforeEach
+    fun setup() {
+        subTaskRepository = mockk()
+        createSubTaskUseCase = CreateSubTaskUseCase(subTaskRepository)
+    }
+
+    @Test
+    fun `should return true when create subtask without any issue`() = runTest {
+        // Given
+        val subTask = SubTask(
+            id = UUID.randomUUID(),
+            title = "SubTask Title",
+            description = "SubTask Description",
+            isCompleted = false,
+            parentTaskId = UUID.randomUUID()
+        )
+        coEvery { subTaskRepository.createSubTask(subTask) } returns true
+
+        // When
+        val result = createSubTaskUseCase(subTask)
+
+        // Then
+        assertTrue(result)
+        coVerify(exactly = 1) { subTaskRepository.createSubTask(subTask) }
+    }
+
+    @Test
+    fun `should return false when repository fails to create subtask`() = runTest {
+        // Given
+        val subTask = SubTask(
+            id = UUID.randomUUID(),
+            title = "SubTask Title",
+            description = "SubTask Description",
+            isCompleted = false,
+            parentTaskId = UUID.randomUUID()
+        )
+        coEvery { subTaskRepository.createSubTask(subTask) } returns false
+
+        // When
+        val result = createSubTaskUseCase(subTask)
+
+        // Then
+        assertFalse(result)
+        coVerify(exactly = 1) { subTaskRepository.createSubTask(subTask) }
+    }
+
+    @Test
+    fun `should pass correct SubTask object to repository`() = runTest {
+        // Given
+        val subTaskId = UUID.randomUUID()
+        val taskId = UUID.randomUUID()
+        val subTask = SubTask(
+            id = subTaskId,
+            title = "Test SubTask",
+            description = "Test Description",
+            isCompleted = true,
+            parentTaskId = taskId
+        )
+        coEvery { subTaskRepository.createSubTask(any()) } returns true
+
+        // When
+        createSubTaskUseCase(subTask)
+
+        // Then
+        coVerify {
+            subTaskRepository.createSubTask(match {
+                it.id == subTaskId && it.title == "Test SubTask" &&
+                        it.parentTaskId == taskId &&
+                        it.isCompleted == true
+            })
+        }
+    }
+}

src/test/kotlin/domain/usecases/sub_task/DeleteSubTaskUseCaseTest.kt

@@ -0,0 +1,68 @@
+package domain.usecases.sub_task
+
+import domain.repositories.SubTaskRepository
+import io.mockk.coEvery
+import io.mockk.coVerify
+import io.mockk.mockk
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import java.util.*
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class DeleteSubTaskUseCaseTest {
+    private lateinit var deleteSubTaskUseCase: DeleteSubTaskUseCase
+    private lateinit var subTaskRepository: SubTaskRepository
+
+    @BeforeEach
+    fun setup() {
+        subTaskRepository = mockk()
+        deleteSubTaskUseCase = DeleteSubTaskUseCase(subTaskRepository)
+    }
+
+    @Test
+    fun `should return true when delete subtask without any issue`() = runTest {
+        // Given
+        val subTaskId = UUID.randomUUID()
+        coEvery { subTaskRepository.deleteSubTask(subTaskId) } returns true
+
+        // When
+        val result = deleteSubTaskUseCase(subTaskId)
+
+        // Then
+        assertTrue(result)
+        coVerify(exactly = 1) { subTaskRepository.deleteSubTask(subTaskId) }
+    }
+
+    @Test
+    fun `should return false when repository fails to delete subtask`() = runTest {
+        // Given
+        val subTaskId = UUID.randomUUID()
+        coEvery { subTaskRepository.deleteSubTask(subTaskId) } returns false
+
+        // When
+        val result = deleteSubTaskUseCase(subTaskId)
+
+        // Then
+        assertFalse(result)
+        coVerify(exactly = 1) { subTaskRepository.deleteSubTask(subTaskId) }
+    }
+
+    @Test
+    fun `should pass correct UUID to repository`() = runTest {
+        // Given
+        val subTaskId = UUID.randomUUID()
+        coEvery { subTaskRepository.deleteSubTask(any()) } returns true
+
+        // When
+        deleteSubTaskUseCase(subTaskId)
+
+        // Then
+        coVerify {
+            subTaskRepository.deleteSubTask(match {
+                it == subTaskId
+            })
+        }
+    }
+}

src/test/kotlin/domain/usecases/sub_task/GetSubTasksByTaskIdUseCaseTest.kt

@@ -0,0 +1,85 @@
+package domain.usecases.sub_task
+
+import domain.models.SubTask
+import domain.repositories.SubTaskRepository
+import io.mockk.coEvery
+import io.mockk.coVerify
+import io.mockk.mockk
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import java.util.*
+import kotlin.test.assertEquals
+
+class GetSubTasksByTaskIdUseCaseTest {
+    private lateinit var getSubTasksByTaskIdUseCase: GetSubTasksByTaskIdUseCase
+    private lateinit var subTaskRepository: SubTaskRepository
+
+    @BeforeEach
+    fun setup() {
+        subTaskRepository = mockk()
+        getSubTasksByTaskIdUseCase = GetSubTasksByTaskIdUseCase(subTaskRepository)
+    }
+
+    @Test
+    fun `should return list of subtasks when repository returns data`() = runTest {
+        // Given
+        val taskId = UUID.randomUUID()
+        val subTasks = listOf(
+            SubTask(
+                id = UUID.randomUUID(),
+                title = "SubTask 1",
+                description = "Description 1",
+                isCompleted = false,
+                parentTaskId = taskId
+            ),
+            SubTask(
+                id = UUID.randomUUID(),
+                title = "SubTask 2",
+                description = "Description 2",
+                isCompleted = true,
+                parentTaskId = taskId
+            )
+        )
+        coEvery { subTaskRepository.getSubTasksByTaskId(taskId) } returns subTasks
+
+        // When
+        val result = getSubTasksByTaskIdUseCase(taskId)
+
+        // Then
+        assertEquals(subTasks, result)
+        coVerify(exactly = 1) { subTaskRepository.getSubTasksByTaskId(taskId) }
+    }
+
+    @Test
+    fun `should return empty list when repository returns no data`() = runTest {
+        // Given
+        val taskId = UUID.randomUUID()
+        val emptyList = emptyList<SubTask>()
+        coEvery { subTaskRepository.getSubTasksByTaskId(taskId) } returns emptyList
+
+        // When
+        val result = getSubTasksByTaskIdUseCase(taskId)
+
+        // Then
+        assertEquals(emptyList, result)
+        coVerify(exactly = 1) { subTaskRepository.getSubTasksByTaskId(taskId) }
+    }
+
+    @Test
+    fun `should pass correct taskId to repository`() = runTest {
+        // Given
+        val taskId = UUID.randomUUID()
+        coEvery { subTaskRepository.getSubTasksByTaskId(any()) } returns emptyList()
+
+        // When
+        getSubTasksByTaskIdUseCase(taskId)
+
+        // Then
+        coVerify {
+            subTaskRepository.getSubTasksByTaskId(match {
+                it == taskId
+            })
+        }
+    }
+}

src/test/kotlin/domain/usecases/sub_task/UpdateSubTaskUseCaseTest.kt

@@ -0,0 +1,93 @@
+package domain.usecases.sub_task
+
+import domain.models.SubTask
+import domain.repositories.SubTaskRepository
+import io.mockk.coEvery
+import io.mockk.coVerify
+import io.mockk.mockk
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import java.util.*
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class UpdateSubTaskUseCaseTest {
+    private lateinit var updateSubTaskUseCase: UpdateSubTaskUseCase
+    private lateinit var subTaskRepository: SubTaskRepository
+
+    @BeforeEach
+    fun setup() {
+        subTaskRepository = mockk()
+        updateSubTaskUseCase = UpdateSubTaskUseCase(subTaskRepository)
+    }
+
+    @Test
+    fun `should return true when update subtask without any issue`() = runTest {
+        // Given
+        val subTask = SubTask(
+            id = UUID.randomUUID(),
+            title = "Updated SubTask Title",
+            description = "Updated SubTask Description",
+            isCompleted = true,
+            parentTaskId = UUID.randomUUID()
+        )
+        coEvery { subTaskRepository.updateSubTask(subTask) } returns true
+
+        // When
+        val result = updateSubTaskUseCase(subTask)
+
+        // Then
+        assertTrue(result)
+        coVerify(exactly = 1) { subTaskRepository.updateSubTask(subTask) }
+    }
+
+    @Test
+    fun `should return false when repository fails to update subtask`() = runTest {
+        // Given
+        val subTask = SubTask(
+            id = UUID.randomUUID(),
+            title = "Updated SubTask Title",
+            description = "Updated SubTask Description",
+            isCompleted = true,
+            parentTaskId = UUID.randomUUID()
+        )
+        coEvery { subTaskRepository.updateSubTask(subTask) } returns false
+
+        // When
+        val result = updateSubTaskUseCase(subTask)
+
+        // Then
+        assertFalse(result)
+        coVerify(exactly = 1) { subTaskRepository.updateSubTask(subTask) }
+    }
+
+    @Test
+    fun `should pass correct SubTask object to repository`() = runTest {
+        // Given
+        val subTaskId = UUID.randomUUID()
+        val taskId = UUID.randomUUID()
+        val subTask = SubTask(
+            id = subTaskId,
+            title = "Test Updated SubTask",
+            description = "Test Updated Description",
+            isCompleted = true,
+            parentTaskId = taskId
+        )
+        coEvery { subTaskRepository.updateSubTask(any()) } returns true
+
+        // When
+        updateSubTaskUseCase(subTask)
+
+        // Then
+        coVerify {
+            subTaskRepository.updateSubTask(match {
+                it.id == subTaskId &&
+                it.title == "Test Updated SubTask" &&
+                it.description == "Test Updated Description" &&
+                it.parentTaskId == taskId &&
+                it.isCompleted == true
+            })
+        }
+    }
+}