diff --git a/src/main/kotlin/data/UserCache.kt b/src/main/kotlin/data/UserCache.kt
index c691878..7fcc3b3 100644
--- a/src/main/kotlin/data/UserCache.kt
+++ b/src/main/kotlin/data/UserCache.kt
@@ -6,7 +6,6 @@ import com.berlin.data.mapper.UserMapper
 import com.berlin.domain.model.Permission
 import com.berlin.domain.model.user.User
 import com.berlin.domain.permission.assignPermissions
-import com.berlin.domain.repository.AuthenticationRepository
 
 class UserCache(
     user: User,
diff --git a/src/main/kotlin/di/useCaseModule.kt b/src/main/kotlin/di/useCaseModule.kt
index 6b9e00d..5395805 100644
--- a/src/main/kotlin/di/useCaseModule.kt
+++ b/src/main/kotlin/di/useCaseModule.kt
@@ -18,11 +18,16 @@ import com.berlin.domain.usecase.task_state.GetTaskStateByIdUseCase
 import com.berlin.domain.usecase.task_state.GetTaskStateByTaskIdUseCase
 import com.berlin.domain.usecase.task_state.GetTasksByTaskStateIdUseCase
 import com.berlin.domain.usecase.task_state.UpdateTaskStateUseCase
+import com.berlin.domain.usecase.utils.validation.NonBlankNonNumericValidator
+import com.berlin.domain.usecase.utils.validation.Validator
 import domain.usecase.auth_service.LoginUserUseCase
 import org.koin.core.module.dsl.singleOf
+import org.koin.dsl.bind
 import org.koin.dsl.module
 
 val useCaseModule = module {
+    singleOf(::NonBlankNonNumericValidator) bind Validator::class
+
     singleOf(::CreateTaskUseCase)
     singleOf(::AssignTaskUseCase)
     singleOf(::DeleteTaskUseCase)
diff --git a/src/main/kotlin/domain/usecase/audit_system/GetAuditLogsByProjectIdUseCase.kt b/src/main/kotlin/domain/usecase/audit_system/GetAuditLogsByProjectIdUseCase.kt
index be710be..a56d7cb 100644
--- a/src/main/kotlin/domain/usecase/audit_system/GetAuditLogsByProjectIdUseCase.kt
+++ b/src/main/kotlin/domain/usecase/audit_system/GetAuditLogsByProjectIdUseCase.kt
@@ -3,19 +3,19 @@ package com.berlin.domain.usecase.audit_system
 import com.berlin.domain.exception.InvalidProjectIdException
 import com.berlin.domain.model.AuditLog
 import com.berlin.domain.repository.AuditRepository
+import com.berlin.domain.usecase.utils.validation.Validator
+
 
 class GetAuditLogsByProjectIdUseCase(
-    private val auditRepository: AuditRepository
+    private val auditRepository: AuditRepository,
+    private val validator: Validator
 ) {
 
     operator fun invoke(projectId: String): List<AuditLog> {
 
-        if (!validateProjectId(projectId))
+        if (!validator.isValid(projectId))
             throw InvalidProjectIdException("Project ID must not be empty, blank, or purely numeric")
 
         return auditRepository.getAuditLogsByProjectId(projectId)
     }
-
-    private fun validateProjectId(projectId: String): Boolean =
-        projectId.isNotBlank() && !(projectId.all { it.isDigit() })
 }
\ No newline at end of file
diff --git a/src/main/kotlin/domain/usecase/audit_system/GetAuditLogsByTaskIdUseCase.kt b/src/main/kotlin/domain/usecase/audit_system/GetAuditLogsByTaskIdUseCase.kt
index 22b209e..0e45195 100644
--- a/src/main/kotlin/domain/usecase/audit_system/GetAuditLogsByTaskIdUseCase.kt
+++ b/src/main/kotlin/domain/usecase/audit_system/GetAuditLogsByTaskIdUseCase.kt
@@ -3,17 +3,18 @@ package com.berlin.domain.usecase.audit_system
 import com.berlin.domain.exception.InvalidTaskIdException
 import com.berlin.domain.model.AuditLog
 import com.berlin.domain.repository.AuditRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 
 class GetAuditLogsByTaskIdUseCase(
     private val auditRepository: AuditRepository,
+    private val validator: Validator
 ) {
 
     operator fun invoke(taskId: String): List<AuditLog> {
 
-        if (!validateTaskId(taskId)) throw InvalidTaskIdException("Task ID must not be empty, blank, or purely numeric")
+        if (!validator.isValid(taskId))
+            throw InvalidTaskIdException("Task ID must not be empty, blank, or purely numeric")
 
         return auditRepository.getAuditLogsByTaskId(taskId)
     }
-
-    private fun validateTaskId(projectId: String): Boolean = projectId.isNotBlank() && !(projectId.all { it.isDigit() })
 }
\ No newline at end of file
diff --git a/src/main/kotlin/domain/usecase/audit_system/GetAuditLogsByUserIdUseCase.kt b/src/main/kotlin/domain/usecase/audit_system/GetAuditLogsByUserIdUseCase.kt
index 92508c7..3cbc87e 100644
--- a/src/main/kotlin/domain/usecase/audit_system/GetAuditLogsByUserIdUseCase.kt
+++ b/src/main/kotlin/domain/usecase/audit_system/GetAuditLogsByUserIdUseCase.kt
@@ -3,20 +3,19 @@ package com.berlin.domain.usecase.audit_system
 import com.berlin.domain.exception.InvalidUserIdException
 import com.berlin.domain.model.AuditLog
 import com.berlin.domain.repository.AuditRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 
 class GetAuditLogsByUserIdUseCase(
-    private val auditRepository: AuditRepository
+    private val auditRepository: AuditRepository,
+    private val validator: Validator
 ) {
 
-    operator fun invoke(userId:String): List<AuditLog>{
+    operator fun invoke(userId: String): List<AuditLog> {
 
-        if (!validateUserId(userId))
+        if (!validator.isValid(userId))
             throw InvalidUserIdException("User ID must not be empty, blank, or purely numeric")
 
         return auditRepository.getAuditLogsByUserId(userId)
 
     }
-
-    private fun validateUserId(projectId: String): Boolean =
-        projectId.isNotBlank() && !(projectId.all { it.isDigit() })
 }
\ No newline at end of file
diff --git a/src/main/kotlin/domain/usecase/project/CreateProjectUseCase.kt b/src/main/kotlin/domain/usecase/project/CreateProjectUseCase.kt
index 468144a..af016cd 100644
--- a/src/main/kotlin/domain/usecase/project/CreateProjectUseCase.kt
+++ b/src/main/kotlin/domain/usecase/project/CreateProjectUseCase.kt
@@ -5,6 +5,7 @@ import com.berlin.domain.model.Project
 import com.berlin.domain.repository.ProjectRepository
 import com.berlin.domain.usecase.audit_system.AddAuditLogUseCase
 import com.berlin.domain.usecase.utils.id_generator.IdGenerator
+import com.berlin.domain.usecase.utils.validation.Validator
 import data.UserCache
 
 class CreateProjectUseCase(
@@ -12,6 +13,7 @@ class CreateProjectUseCase(
     private val idGenerator: IdGenerator,
     private val addAuditLogUseCase: AddAuditLogUseCase,
     private val cashedUser: UserCache,
+    private val validator: Validator
 ) {
     operator fun invoke(
         projectName: String,
@@ -19,7 +21,7 @@ class CreateProjectUseCase(
         stateId: List<String>?,
         taskId: List<String>?,
     ): String {
-        if (validateProjectName(projectName)) {
+        if (validator.isValid(projectName)) {
             val newProject = Project(
                 id = idGenerator.generateId(projectName),
                 title = projectName,
@@ -42,7 +44,4 @@ class CreateProjectUseCase(
             throw Exception("Project Name must not be empty or blank")
         }
     }
-
-    private fun validateProjectName(projectName: String): Boolean =
-        projectName.isNotBlank() && !(projectName.all { it.isDigit() })
 }
\ No newline at end of file
diff --git a/src/main/kotlin/domain/usecase/project/DeleteProjectUseCase.kt b/src/main/kotlin/domain/usecase/project/DeleteProjectUseCase.kt
index e7f1833..b74b351 100644
--- a/src/main/kotlin/domain/usecase/project/DeleteProjectUseCase.kt
+++ b/src/main/kotlin/domain/usecase/project/DeleteProjectUseCase.kt
@@ -1,20 +1,21 @@
 package com.berlin.domain.usecase.project
 
 import com.berlin.domain.exception.InvalidProjectIdException
-import com.berlin.domain.exception.ProjectNotFoundException
 import com.berlin.domain.model.AuditLog
 import com.berlin.domain.repository.ProjectRepository
 import com.berlin.domain.usecase.audit_system.AddAuditLogUseCase
+import com.berlin.domain.usecase.utils.validation.Validator
 import data.UserCache
 
 class DeleteProjectUseCase(
     private val projectRepository: ProjectRepository,
     private val addAuditLogUseCase: AddAuditLogUseCase,
     private val cashedUser: UserCache,
+    private val validator: Validator
 ) {
     operator fun invoke(projectId: String): String {
 
-        if (!validateProjectId(projectId)) {
+        if (!validator.isValid(projectId)) {
             throw InvalidProjectIdException("Project ID must not be empty or blank")
         }
 
@@ -29,8 +30,4 @@ class DeleteProjectUseCase(
 
         return deletedProject
     }
-
-    private fun validateProjectId(projectId: String): Boolean =
-        projectId.isNotBlank() && !(projectId.all { it.isDigit() })
-
 }
\ No newline at end of file
diff --git a/src/main/kotlin/domain/usecase/project/GetProjectByIdUseCase.kt b/src/main/kotlin/domain/usecase/project/GetProjectByIdUseCase.kt
index 75255d3..85b57cb 100644
--- a/src/main/kotlin/domain/usecase/project/GetProjectByIdUseCase.kt
+++ b/src/main/kotlin/domain/usecase/project/GetProjectByIdUseCase.kt
@@ -3,19 +3,17 @@ package com.berlin.domain.usecase.project
 import com.berlin.domain.exception.InvalidProjectIdException
 import com.berlin.domain.repository.ProjectRepository
 import com.berlin.domain.model.Project
+import com.berlin.domain.usecase.utils.validation.Validator
 
 class GetProjectByIdUseCase (
-    private val projectRepository: ProjectRepository
+    private val projectRepository: ProjectRepository,
+    private val validator: Validator
 ) {
 
     operator fun invoke(projectId: String): Project {
-        if(!validateProjectId(projectId))
+        if(!validator.isValid(projectId))
             throw InvalidProjectIdException("project id must not be empty, blank, or purely numeric")
 
         return projectRepository.getProjectById(projectId)
     }
-
-    private fun validateProjectId(projectId: String): Boolean =
-        projectId.isNotBlank() && !(projectId.all { it.isDigit() })
-
 }
\ No newline at end of file
diff --git a/src/main/kotlin/domain/usecase/project/UpdateProjectUseCase.kt b/src/main/kotlin/domain/usecase/project/UpdateProjectUseCase.kt
index 14bd1b4..a6ea810 100644
--- a/src/main/kotlin/domain/usecase/project/UpdateProjectUseCase.kt
+++ b/src/main/kotlin/domain/usecase/project/UpdateProjectUseCase.kt
@@ -5,15 +5,17 @@ import com.berlin.domain.model.AuditLog
 import com.berlin.domain.model.Project
 import com.berlin.domain.repository.ProjectRepository
 import com.berlin.domain.usecase.audit_system.AddAuditLogUseCase
+import com.berlin.domain.usecase.utils.validation.Validator
 import data.UserCache
 
 class UpdateProjectUseCase(
     private val projectRepository: ProjectRepository,
     private val addAuditLogUseCase: AddAuditLogUseCase,
     private val cashedUser: UserCache,
+    private val validator: Validator
 ) {
     operator fun invoke(project: Project): String {
-        if (!validateProjectName(project.title)) throw InvalidProjectException("Project Name must not be empty or blank")
+        if (!validator.isValid(project.title)) throw InvalidProjectException("Project Name must not be empty or blank")
 
         val updatedProject = projectRepository.updateProject(project)
 
@@ -26,7 +28,4 @@ class UpdateProjectUseCase(
 
         return updatedProject
     }
-
-    private fun validateProjectName(projectName: String): Boolean =
-        projectName.isNotBlank() && !(projectName.all { it.isDigit() })
 }
\ No newline at end of file
diff --git a/src/main/kotlin/domain/usecase/task/ChangeTaskStateUseCase.kt b/src/main/kotlin/domain/usecase/task/ChangeTaskStateUseCase.kt
index 76349fc..33ae13f 100644
--- a/src/main/kotlin/domain/usecase/task/ChangeTaskStateUseCase.kt
+++ b/src/main/kotlin/domain/usecase/task/ChangeTaskStateUseCase.kt
@@ -5,19 +5,21 @@ import com.berlin.domain.model.AuditLog
 import com.berlin.domain.model.Task
 import com.berlin.domain.repository.TaskRepository
 import com.berlin.domain.usecase.audit_system.AddAuditLogUseCase
+import com.berlin.domain.usecase.utils.validation.Validator
 import data.UserCache
 
 class ChangeTaskStateUseCase(
     private val taskRepository: TaskRepository,
     private val addAuditLogUseCase: AddAuditLogUseCase,
     private val cashedUser: UserCache,
+    private val validator: Validator
 ) {
 
     operator fun invoke(taskId: String, newStateId: String): Task {
 
         val original = taskRepository.getTaskById(taskId)
 
-        if (!validateStateId(newStateId)) {
+        if (!validator.isValid(newStateId)) {
             throw InvalidTaskStateException("State id must not be empty, blank, or purely numeric")
         }
 
@@ -33,7 +35,4 @@ class ChangeTaskStateUseCase(
 
         return updatedTask
     }
-
-    private fun validateStateId(stateId: String): Boolean =
-        stateId.isNotBlank() && !stateId.all { it.isDigit() }
 }
diff --git a/src/main/kotlin/domain/usecase/task/CreateTaskUseCase.kt b/src/main/kotlin/domain/usecase/task/CreateTaskUseCase.kt
index 2441fe4..09a194a 100644
--- a/src/main/kotlin/domain/usecase/task/CreateTaskUseCase.kt
+++ b/src/main/kotlin/domain/usecase/task/CreateTaskUseCase.kt
@@ -7,11 +7,13 @@ import com.berlin.domain.model.Task
 import com.berlin.domain.repository.TaskRepository
 import com.berlin.domain.usecase.audit_system.AddAuditLogUseCase
 import com.berlin.domain.usecase.utils.id_generator.IdGenerator
+import com.berlin.domain.usecase.utils.validation.Validator
 
 class CreateTaskUseCase(
     private val taskRepository: TaskRepository,
     private val defaultIdGenerator: IdGenerator,
-    private val addAuditLogUseCase: AddAuditLogUseCase
+    private val addAuditLogUseCase: AddAuditLogUseCase,
+    private val validator: Validator
 ) {
     operator fun invoke(
         projectId: String,
@@ -21,7 +23,7 @@ class CreateTaskUseCase(
         createByUserId: String,
         assignedToUserId: String,
     ): Task {
-        if (validateTaskTitle(title.trim())) {
+        if (validator.isValid(title.trim())) {
             val newTask = Task(
                 id = defaultIdGenerator.generateId(title.trim()),
                 projectId = projectId,
@@ -50,10 +52,6 @@ class CreateTaskUseCase(
         }
     }
 
-    private fun validateTaskTitle(title: String): Boolean {
-        return title.isNotBlank() && !title.any { it.isDigit() }
-    }
-
     private fun validateUniqueTask(taskId: String): Boolean {
         return try {
             taskRepository.getTaskById(taskId)
diff --git a/src/main/kotlin/domain/usecase/task/DeleteTaskUseCase.kt b/src/main/kotlin/domain/usecase/task/DeleteTaskUseCase.kt
index 2e8658d..562cefc 100644
--- a/src/main/kotlin/domain/usecase/task/DeleteTaskUseCase.kt
+++ b/src/main/kotlin/domain/usecase/task/DeleteTaskUseCase.kt
@@ -3,15 +3,17 @@ package com.berlin.domain.usecase.task
 import com.berlin.domain.model.AuditLog
 import com.berlin.domain.repository.TaskRepository
 import com.berlin.domain.usecase.audit_system.AddAuditLogUseCase
+import com.berlin.domain.usecase.utils.validation.Validator
 import data.UserCache
 
 class DeleteTaskUseCase(
     private val taskRepository: TaskRepository,
     private val addAuditLogUseCase: AddAuditLogUseCase,
     private val cashedUser: UserCache,
+    private val validator: Validator
 ) {
     operator fun invoke(taskId: String) : String {
-        if (!validateTaskId(taskId)) {
+        if (!validator.isValid(taskId)) {
             throw Exception("Project ID must not be empty or blank")
         }
         taskRepository.deleteTask(taskId)
@@ -25,6 +27,4 @@ class DeleteTaskUseCase(
 
         return "Deleted."
     }
-
-    private fun validateTaskId(taskId: String): Boolean = taskId.isNotBlank() && !(taskId.all { it.isDigit() })
 }
diff --git a/src/main/kotlin/domain/usecase/task/GetTaskByIdUseCase.kt b/src/main/kotlin/domain/usecase/task/GetTaskByIdUseCase.kt
index 97e6080..f8dffc7 100644
--- a/src/main/kotlin/domain/usecase/task/GetTaskByIdUseCase.kt
+++ b/src/main/kotlin/domain/usecase/task/GetTaskByIdUseCase.kt
@@ -3,20 +3,19 @@ package com.berlin.domain.usecase.task
 import com.berlin.domain.exception.InvalidTaskIdException
 import com.berlin.domain.model.Task
 import com.berlin.domain.repository.TaskRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 
 class GetTaskByIdUseCase(
     private val taskRepository: TaskRepository,
+    private val validator: Validator
 ) {
 
     operator fun invoke(taskId: String): Task {
 
-        if (!validateTaskId(taskId)) {
+        if (!validator.isValid(taskId)) {
             throw InvalidTaskIdException("Task id must not be empty, blank, or purely numeric")
         }
 
         return taskRepository.getTaskById(taskId)
     }
-
-    private fun validateTaskId(id: String): Boolean =
-        id.isNotBlank() && !id.all { it.isDigit() }
 }
diff --git a/src/main/kotlin/domain/usecase/task/GetTasksByProjectUseCase.kt b/src/main/kotlin/domain/usecase/task/GetTasksByProjectUseCase.kt
index 8ab6b7b..23a15f4 100644
--- a/src/main/kotlin/domain/usecase/task/GetTasksByProjectUseCase.kt
+++ b/src/main/kotlin/domain/usecase/task/GetTasksByProjectUseCase.kt
@@ -3,19 +3,18 @@ package com.berlin.domain.usecase.task
 import com.berlin.domain.exception.InvalidProjectIdException
 import com.berlin.domain.model.Task
 import com.berlin.domain.repository.TaskRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 
 class GetTasksByProjectUseCase(
-    private val taskRepository: TaskRepository
+    private val taskRepository: TaskRepository,
+    private val validator: Validator
 ) {
 
     operator fun invoke(projectId: String): List<Task> {
 
-        if (!validateProjectId(projectId)) {
+        if (!validator.isValid(projectId)) {
             throw InvalidProjectIdException("Project id must not be empty, blank, or purely numeric")
         }
         return taskRepository.getTasksByProjectId(projectId)
     }
-
-    private fun validateProjectId(id: String): Boolean =
-        id.isNotBlank() && !id.all { it.isDigit() }
 }
\ No newline at end of file
diff --git a/src/main/kotlin/domain/usecase/task_state/CreateTaskStateUseCase.kt b/src/main/kotlin/domain/usecase/task_state/CreateTaskStateUseCase.kt
index 99bd0d5..5180a30 100644
--- a/src/main/kotlin/domain/usecase/task_state/CreateTaskStateUseCase.kt
+++ b/src/main/kotlin/domain/usecase/task_state/CreateTaskStateUseCase.kt
@@ -5,13 +5,15 @@ import com.berlin.domain.exception.InvalidStateNameException
 import com.berlin.domain.repository.TaskStateRepository
 import com.berlin.domain.model.TaskState
 import com.berlin.domain.usecase.utils.id_generator.IdGeneratorImplementation
+import com.berlin.domain.usecase.utils.validation.Validator
 
 class CreateTaskStateUseCase(
     private val taskStateRepository: TaskStateRepository,
     private val idGenerator: IdGeneratorImplementation,
+    private val validator: Validator
 ) {
     operator fun invoke(stateName: String, projectId: String): String {
-        if (validateStateName(stateName)) {
+        if (validator.isValid(stateName)) {
             val newState = TaskState(
                 id = idGenerator.generateId(stateName),
                 name = stateName,
@@ -22,7 +24,4 @@ class CreateTaskStateUseCase(
             throw InvalidStateNameException("State Name must not be empty or blank")
         }
     }
-
-    private fun validateStateName(stateName: String): Boolean =
-        stateName.isNotBlank() && !(stateName.all { it.isDigit() })
 }
diff --git a/src/main/kotlin/domain/usecase/task_state/DeleteTaskStateUseCase.kt b/src/main/kotlin/domain/usecase/task_state/DeleteTaskStateUseCase.kt
index 0c62942..af5c347 100644
--- a/src/main/kotlin/domain/usecase/task_state/DeleteTaskStateUseCase.kt
+++ b/src/main/kotlin/domain/usecase/task_state/DeleteTaskStateUseCase.kt
@@ -2,19 +2,18 @@ package com.berlin.domain.usecase.task_state
 
 import com.berlin.domain.exception.InvalidStateIdException
 import com.berlin.domain.repository.TaskStateRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 
 class DeleteTaskStateUseCase(
-    private val taskStateRepository: TaskStateRepository
+    private val taskStateRepository: TaskStateRepository,
+    private val validator: Validator
 ) {
 
     operator fun invoke(stateId: String): String {
 
-        if(!validateStateId(stateId))
+        if(!validator.isValid(stateId))
             throw InvalidStateIdException("State ID must not be empty or blank")
 
         return taskStateRepository.deleteState(stateId)
     }
-
-    private fun validateStateId(stateId: String): Boolean =
-        stateId.isNotBlank() && !(stateId.all { it.isDigit() })
 }
\ No newline at end of file
diff --git a/src/main/kotlin/domain/usecase/task_state/GetAllTaskStatesByProjectIdUseCase.kt b/src/main/kotlin/domain/usecase/task_state/GetAllTaskStatesByProjectIdUseCase.kt
index 6770dc9..6a8c702 100644
--- a/src/main/kotlin/domain/usecase/task_state/GetAllTaskStatesByProjectIdUseCase.kt
+++ b/src/main/kotlin/domain/usecase/task_state/GetAllTaskStatesByProjectIdUseCase.kt
@@ -5,15 +5,17 @@ import com.berlin.domain.exception.InvalidProjectIdException
 import com.berlin.domain.model.TaskState
 import com.berlin.domain.repository.ProjectRepository
 import com.berlin.domain.repository.TaskStateRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 
 class GetAllTaskStatesByProjectIdUseCase(
     private val taskStateRepository: TaskStateRepository,
-    private val projectRepository: ProjectRepository
+    private val projectRepository: ProjectRepository,
+    private val validator: Validator
 ) {
 
     operator fun invoke(projectId: String): List<TaskState> {
 
-        return if (!validateProjectId(projectId)) {
+        return if (!validator.isValid(projectId)) {
             throw InvalidProjectIdException("Project ID must not be empty or blank")
 
         } else {
@@ -21,8 +23,4 @@ class GetAllTaskStatesByProjectIdUseCase(
 
         }
     }
-
-    private fun validateProjectId(projectId: String): Boolean =
-        projectId.isNotBlank() && !(projectId.all { it.isDigit() })
-
 }
\ No newline at end of file
diff --git a/src/main/kotlin/domain/usecase/task_state/GetTaskStateByIdUseCase.kt b/src/main/kotlin/domain/usecase/task_state/GetTaskStateByIdUseCase.kt
index 5ba37fa..9804991 100644
--- a/src/main/kotlin/domain/usecase/task_state/GetTaskStateByIdUseCase.kt
+++ b/src/main/kotlin/domain/usecase/task_state/GetTaskStateByIdUseCase.kt
@@ -3,19 +3,17 @@ package com.berlin.domain.usecase.task_state
 import com.berlin.domain.exception.InvalidStateIdException
 import com.berlin.domain.model.TaskState
 import com.berlin.domain.repository.TaskStateRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 
 class GetTaskStateByIdUseCase(
-    private val taskStateRepository: TaskStateRepository
+    private val taskStateRepository: TaskStateRepository,
+    private val validator: Validator
 ) {
 
     operator fun invoke(stateId: String): TaskState {
-        if(!validateStateId(stateId))
+        if(!validator.isValid(stateId))
             throw InvalidStateIdException("State id must not be empty, blank, or purely numeric")
 
         return taskStateRepository.getStateById(stateId)
     }
-
-    private fun validateStateId(stateId: String): Boolean =
-        stateId.isNotBlank() && !(stateId.all { it.isDigit() })
-
 }
\ No newline at end of file
diff --git a/src/main/kotlin/domain/usecase/task_state/GetTaskStateByTaskIdUseCase.kt b/src/main/kotlin/domain/usecase/task_state/GetTaskStateByTaskIdUseCase.kt
index 2bf1541..7b43a95 100644
--- a/src/main/kotlin/domain/usecase/task_state/GetTaskStateByTaskIdUseCase.kt
+++ b/src/main/kotlin/domain/usecase/task_state/GetTaskStateByTaskIdUseCase.kt
@@ -4,21 +4,20 @@ import com.berlin.domain.exception.InvalidTaskIdException
 import com.berlin.domain.model.TaskState
 import com.berlin.domain.repository.TaskStateRepository
 import com.berlin.domain.repository.TaskRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 
 class GetTaskStateByTaskIdUseCase(
     private val taskStateRepository: TaskStateRepository,
-    private val taskRepository: TaskRepository
+    private val taskRepository: TaskRepository,
+    private val validator: Validator
 ) {
 
     operator fun invoke(taskId: String): TaskState? {
-        if (!validateTaskId(taskId)) {
+        if (!validator.isValid(taskId)) {
             throw InvalidTaskIdException("Task ID must not be empty or blank")
 
         } else {
             return taskStateRepository.getStateByTaskId(taskId)
         }
     }
-
-    private fun validateTaskId(taskId: String): Boolean = taskId.isNotBlank() && !(taskId.all { it.isDigit() })
-
 }
\ No newline at end of file
diff --git a/src/main/kotlin/domain/usecase/task_state/GetTasksByTaskStateIdUseCase.kt b/src/main/kotlin/domain/usecase/task_state/GetTasksByTaskStateIdUseCase.kt
index e3c909b..d40e886 100644
--- a/src/main/kotlin/domain/usecase/task_state/GetTasksByTaskStateIdUseCase.kt
+++ b/src/main/kotlin/domain/usecase/task_state/GetTasksByTaskStateIdUseCase.kt
@@ -4,19 +4,19 @@ import com.berlin.domain.exception.InvalidStateIdException
 import com.berlin.domain.exception.TaskNotFoundException
 import com.berlin.domain.model.Task
 import com.berlin.domain.repository.TaskStateRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 
 class GetTasksByTaskStateIdUseCase(
     private val taskStateRepository: TaskStateRepository,
+    private val validator: Validator
 ) {
 
     operator fun invoke(stateId: String): List<Task> {
-        if (!validateStateId(stateId)) {
+        if (!validator.isValid(stateId)) {
             throw InvalidStateIdException("State ID must not be empty or blank")
         } else {
             return taskStateRepository.getTasksByStateId(stateId)
                 ?: throw TaskNotFoundException("No tasks found for state ID $stateId")
         }
     }
-
-    private fun validateStateId(stateId: String): Boolean = stateId.isNotBlank() && !(stateId.all { it.isDigit() })
 }
\ No newline at end of file
diff --git a/src/main/kotlin/domain/usecase/task_state/UpdateTaskStateUseCase.kt b/src/main/kotlin/domain/usecase/task_state/UpdateTaskStateUseCase.kt
index 6e17b0b..aa44caa 100644
--- a/src/main/kotlin/domain/usecase/task_state/UpdateTaskStateUseCase.kt
+++ b/src/main/kotlin/domain/usecase/task_state/UpdateTaskStateUseCase.kt
@@ -3,12 +3,14 @@ package com.berlin.domain.usecase.task_state
 import com.berlin.domain.exception.InvalidStateNameException
 import com.berlin.domain.model.TaskState
 import com.berlin.domain.repository.TaskStateRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 
 class UpdateTaskStateUseCase(
     private val taskStateRepository: TaskStateRepository,
+    private val validator: Validator
 ) {
     operator fun invoke(stateId: String, newStateName: String, projectId: String): String {
-        if (!validateStateName(newStateName))
+        if (!validator.isValid(newStateName))
             throw InvalidStateNameException("State Name must not be empty or blank")
         val updatedState = TaskState(
             id = stateId,
@@ -18,7 +20,4 @@ class UpdateTaskStateUseCase(
         return taskStateRepository.updateState(updatedState)
     }
 
-
-    private fun validateStateName(stateName: String): Boolean =
-        stateName.isNotBlank() && !(stateName.all { it.isDigit() })
 }
\ No newline at end of file
diff --git a/src/main/kotlin/domain/usecase/utils/validation/NonBlankNonNumericValidator.kt b/src/main/kotlin/domain/usecase/utils/validation/NonBlankNonNumericValidator.kt
new file mode 100644
index 0000000..56b8b76
--- /dev/null
+++ b/src/main/kotlin/domain/usecase/utils/validation/NonBlankNonNumericValidator.kt
@@ -0,0 +1,6 @@
+package com.berlin.domain.usecase.utils.validation
+
+class NonBlankNonNumericValidator : Validator{
+    override fun isValid(input: String): Boolean =
+      input.isNotBlank() && !(input.all {it.isDigit()})
+    }
\ No newline at end of file
diff --git a/src/main/kotlin/domain/usecase/utils/validation/Validator.kt b/src/main/kotlin/domain/usecase/utils/validation/Validator.kt
new file mode 100644
index 0000000..e3adda9
--- /dev/null
+++ b/src/main/kotlin/domain/usecase/utils/validation/Validator.kt
@@ -0,0 +1,5 @@
+package com.berlin.domain.usecase.utils.validation
+
+interface Validator {
+    fun isValid(input: String):Boolean
+}
\ No newline at end of file
diff --git a/src/test/kotlin/domain/usecase/audit_system/GetAuditLogsByProjectIdUseCaseTest.kt b/src/test/kotlin/domain/usecase/audit_system/GetAuditLogsByProjectIdUseCaseTest.kt
index 85e55e8..e47d42e 100644
--- a/src/test/kotlin/domain/usecase/audit_system/GetAuditLogsByProjectIdUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/audit_system/GetAuditLogsByProjectIdUseCaseTest.kt
@@ -1,10 +1,10 @@
-package com.berlin.domain.usecase.auditSystem
+package com.berlin.domain.usecase.audit_system
 
 import com.berlin.domain.exception.InvalidProjectIdException
 import com.berlin.domain.model.AuditLog
 import com.berlin.helper.generateAuditLog
 import com.berlin.domain.repository.AuditRepository
-import com.berlin.domain.usecase.audit_system.GetAuditLogsByProjectIdUseCase
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.google.common.truth.Truth.assertThat
 import io.mockk.every
 import io.mockk.mockk
@@ -18,11 +18,12 @@ import org.junit.jupiter.params.provider.ValueSource
 class GetAuditLogsByProjectIdUseCaseTest {
 
     private val auditRepository: AuditRepository = mockk(relaxed = true)
+    private val validator:Validator= mockk(relaxed = true)
     private lateinit var getAuditLogsByProjectIdUseCase: GetAuditLogsByProjectIdUseCase
 
     @BeforeEach
     fun setup() {
-        getAuditLogsByProjectIdUseCase = GetAuditLogsByProjectIdUseCase(auditRepository)
+        getAuditLogsByProjectIdUseCase = GetAuditLogsByProjectIdUseCase(auditRepository, validator )
     }
 
     @Test
@@ -32,6 +33,7 @@ class GetAuditLogsByProjectIdUseCaseTest {
         val logs = listOf(
             generateAuditLog(id = "A2", entityId = projectId, entityType = AuditLog.EntityType.PROJECT)
         )
+        every { validator.isValid(projectId) } returns true
         every { auditRepository.getAuditLogsByProjectId(projectId) } returns logs
 
         //When
diff --git a/src/test/kotlin/domain/usecase/audit_system/GetAuditLogsByTaskIdUseCaseTest.kt b/src/test/kotlin/domain/usecase/audit_system/GetAuditLogsByTaskIdUseCaseTest.kt
index b62edb4..27643b8 100644
--- a/src/test/kotlin/domain/usecase/audit_system/GetAuditLogsByTaskIdUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/audit_system/GetAuditLogsByTaskIdUseCaseTest.kt
@@ -5,6 +5,7 @@ import com.berlin.domain.model.AuditLog
 import com.berlin.helper.generateAuditLog
 import com.berlin.domain.repository.AuditRepository
 import com.berlin.domain.usecase.audit_system.GetAuditLogsByTaskIdUseCase
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.google.common.truth.Truth.assertThat
 import io.mockk.every
 import io.mockk.mockk
@@ -16,11 +17,12 @@ import org.junit.jupiter.params.provider.ValueSource
 
 class GetAuditLogsByTaskIdUseCaseTest {
     private val auditRepository: AuditRepository = mockk(relaxed = true)
+    private val validator: Validator = mockk(relaxed = true)
     private lateinit var getAuditLogsByTaskIdUseCase: GetAuditLogsByTaskIdUseCase
 
     @BeforeEach
     fun setup() {
-        getAuditLogsByTaskIdUseCase = GetAuditLogsByTaskIdUseCase(auditRepository)
+        getAuditLogsByTaskIdUseCase = GetAuditLogsByTaskIdUseCase(auditRepository,validator)
     }
 
     @Test
@@ -30,6 +32,7 @@ class GetAuditLogsByTaskIdUseCaseTest {
         val logs = listOf(
             generateAuditLog(id = "A3", entityId = taskId, entityType = AuditLog.EntityType.TASK)
         )
+        every { validator.isValid(taskId) } returns true
         every { auditRepository.getAuditLogsByTaskId(taskId) } returns logs
 
         //When
diff --git a/src/test/kotlin/domain/usecase/audit_system/GetAuditLogsByUserIdUseCaseTest.kt b/src/test/kotlin/domain/usecase/audit_system/GetAuditLogsByUserIdUseCaseTest.kt
index 664d2eb..5ee4c96 100644
--- a/src/test/kotlin/domain/usecase/audit_system/GetAuditLogsByUserIdUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/audit_system/GetAuditLogsByUserIdUseCaseTest.kt
@@ -1,9 +1,9 @@
-package com.berlin.domain.usecase.auditSystem
+package com.berlin.domain.usecase.audit_system
 
 import com.berlin.domain.exception.InvalidUserIdException
 import com.berlin.helper.generateAuditLog
 import com.berlin.domain.repository.AuditRepository
-import com.berlin.domain.usecase.audit_system.GetAuditLogsByUserIdUseCase
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.google.common.truth.Truth.assertThat
 import io.mockk.every
 import io.mockk.mockk
@@ -16,11 +16,12 @@ import org.junit.jupiter.params.provider.ValueSource
 
 class GetAuditLogsByUserIdUseCaseTest {
     private val auditRepository: AuditRepository = mockk(relaxed = true)
+    private val validator: Validator = mockk(relaxed = true)
     private lateinit var getAuditLogsByUserIdUseCase: GetAuditLogsByUserIdUseCase
 
     @BeforeEach
     fun setup() {
-        getAuditLogsByUserIdUseCase = GetAuditLogsByUserIdUseCase(auditRepository)
+        getAuditLogsByUserIdUseCase = GetAuditLogsByUserIdUseCase(auditRepository,validator)
     }
 
     @Test
@@ -30,6 +31,7 @@ class GetAuditLogsByUserIdUseCaseTest {
         val logs = listOf(
             generateAuditLog(createdBy = generateAuditLog().createdByUserId)
         )
+        every { validator.isValid(userId) } returns true
         every { auditRepository.getAuditLogsByUserId(userId) } returns logs
 
         //When
@@ -45,6 +47,7 @@ class GetAuditLogsByUserIdUseCaseTest {
     fun `should return empty list when no audit logs found for user ID`() {
         // Given
         val userId = "invalid"
+        every { validator.isValid(userId) } returns true
         every { auditRepository.getAuditLogsByUserId(userId) } returns emptyList()
 
         //When
diff --git a/src/test/kotlin/domain/usecase/project/CreateProjectUseCaseTest.kt b/src/test/kotlin/domain/usecase/project/CreateProjectUseCaseTest.kt
index 8943396..a99045f 100644
--- a/src/test/kotlin/domain/usecase/project/CreateProjectUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/project/CreateProjectUseCaseTest.kt
@@ -4,6 +4,7 @@ import com.berlin.domain.exception.InvalidProjectException
 import com.berlin.domain.repository.ProjectRepository
 import com.berlin.domain.usecase.audit_system.AddAuditLogUseCase
 import com.berlin.domain.usecase.utils.id_generator.IdGenerator
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.berlin.helper.projectHelper
 import com.google.common.truth.Truth.assertThat
 import data.UserCache
@@ -22,17 +23,19 @@ class CreateProjectUseCaseTest {
     private val projectRepository: ProjectRepository = mockk(relaxed = true)
     private val addAuditLogUseCase: AddAuditLogUseCase = mockk(relaxed = true)
     private val cashedUser: UserCache = mockk(relaxed = true)
+    private val validator: Validator = mockk(relaxed = true)
 
     @BeforeEach
     fun setup() {
         val idGenerator: IdGenerator = mockk(relaxed = true)
-        createProjectUseCase = CreateProjectUseCase(projectRepository, idGenerator, addAuditLogUseCase, cashedUser)
+        createProjectUseCase = CreateProjectUseCase(projectRepository, idGenerator, addAuditLogUseCase, cashedUser,validator)
     }
 
     @Test
     fun `createNewProject should log audit when project is created successfully`() {
         // Given
         val validProject = projectHelper()
+        every { validator.isValid(any()) } returns true
         every { projectRepository.createProject(any()) } returns "Creation Successfully"
         every { cashedUser.currentUser.id } returns "user_123"
 
diff --git a/src/test/kotlin/domain/usecase/project/DeleteProjectUseCaseTest.kt b/src/test/kotlin/domain/usecase/project/DeleteProjectUseCaseTest.kt
index c1b6a17..04d23eb 100644
--- a/src/test/kotlin/domain/usecase/project/DeleteProjectUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/project/DeleteProjectUseCaseTest.kt
@@ -3,6 +3,7 @@ package com.berlin.domain.usecase.project
 import com.berlin.domain.exception.InvalidProjectException
 import com.berlin.domain.repository.ProjectRepository
 import com.berlin.domain.usecase.audit_system.AddAuditLogUseCase
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.google.common.truth.Truth.assertThat
 import data.UserCache
 import io.mockk.every
@@ -20,17 +21,19 @@ class DeleteProjectUseCaseTest {
     private val projectRepository: ProjectRepository = mockk(relaxed = true)
     private val addAuditLogUseCase: AddAuditLogUseCase = mockk(relaxed = true)
     private val cashedUser: UserCache = mockk(relaxed = true)
+    private val validator: Validator = mockk(relaxed = true)
 
     @BeforeEach
     fun setup() {
         deleteProjectUseCase = DeleteProjectUseCase(
-            projectRepository, addAuditLogUseCase, cashedUser
+            projectRepository, addAuditLogUseCase, cashedUser,validator
         )
     }
 
     @Test
     fun `should return Deleted Successfully when project deleted successfully`() {
         // Given
+        every { validator.isValid(any()) } returns true
         every { projectRepository.deleteProject(any()) } returns "Deleted Successfully"
         every { cashedUser.currentUser.id } returns "user_123"
 
@@ -49,6 +52,7 @@ class DeleteProjectUseCaseTest {
     @Test
     fun `should return throw ProjectNotFoundException when project deletion fails`() {
         // Given
+        every { validator.isValid("P1") } returns true
         every { projectRepository.deleteProject("P1") } throws InvalidProjectException("")
 
         // When// Then
@@ -62,6 +66,7 @@ class DeleteProjectUseCaseTest {
     @Test
     fun `should throw exception when project id does not exists`() {
         // Given
+        every { validator.isValid(any()) } returns true
         every { projectRepository.deleteProject(any()) } throws InvalidProjectException("")
 
         // When// Then
diff --git a/src/test/kotlin/domain/usecase/project/GetProjectByIdUseCaseTest.kt b/src/test/kotlin/domain/usecase/project/GetProjectByIdUseCaseTest.kt
index b9cc582..9928b21 100644
--- a/src/test/kotlin/domain/usecase/project/GetProjectByIdUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/project/GetProjectByIdUseCaseTest.kt
@@ -2,6 +2,7 @@ package com.berlin.domain.usecase.project
 
 import com.berlin.domain.exception.ProjectNotFoundException
 import com.berlin.domain.repository.ProjectRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.berlin.helper.projectHelper
 import com.google.common.truth.Truth.assertThat
 import io.mockk.every
@@ -16,16 +17,18 @@ class GetProjectByIdUseCaseTest {
 
     private lateinit var getProjectByIdUseCase: GetProjectByIdUseCase
     private val projectRepository: ProjectRepository = mockk(relaxed = true)
+    private val validator: Validator = mockk(relaxed = true)
 
     @BeforeEach
     fun setup() {
-        getProjectByIdUseCase = GetProjectByIdUseCase(projectRepository)
+        getProjectByIdUseCase = GetProjectByIdUseCase(projectRepository,validator)
     }
 
     @Test
     fun `should return project when valid project id exists`() {
         // Given
         val expectedProject = projectHelper()
+        every { validator.isValid("P1") } returns true
         every { projectRepository.getProjectById("P1") } returns expectedProject
 
         // When
@@ -38,6 +41,7 @@ class GetProjectByIdUseCaseTest {
     @Test
     fun `should throw exception when project id does not exist`() {
         // Given
+        every { validator.isValid(any()) } returns true
         every { projectRepository.getProjectById(any()) } throws ProjectNotFoundException("")
         // When // Then
         assertThrows<ProjectNotFoundException> { getProjectByIdUseCase("P2") }
diff --git a/src/test/kotlin/domain/usecase/project/UpdateProjectUseCaseTest.kt b/src/test/kotlin/domain/usecase/project/UpdateProjectUseCaseTest.kt
index 929ddbe..afe805f 100644
--- a/src/test/kotlin/domain/usecase/project/UpdateProjectUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/project/UpdateProjectUseCaseTest.kt
@@ -3,6 +3,7 @@ package com.berlin.domain.usecase.project
 import com.berlin.domain.exception.InvalidProjectException
 import com.berlin.domain.repository.ProjectRepository
 import com.berlin.domain.usecase.audit_system.AddAuditLogUseCase
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.berlin.helper.projectHelper
 import com.google.common.truth.Truth.assertThat
 import data.UserCache
@@ -21,11 +22,12 @@ class UpdateProjectUseCaseTest {
     private val projectRepository: ProjectRepository = mockk(relaxed = true)
     private val addAuditLogUseCase: AddAuditLogUseCase = mockk(relaxed = true)
     private val cashedUser: UserCache = mockk(relaxed = true)
+    private val validator: Validator = mockk(relaxed = true)
 
     @BeforeEach
     fun setup() {
         updateProjectUseCase = UpdateProjectUseCase(
-            projectRepository, addAuditLogUseCase, cashedUser
+            projectRepository, addAuditLogUseCase, cashedUser,validator
         )
     }
 
@@ -33,6 +35,7 @@ class UpdateProjectUseCaseTest {
     fun `should return Updated Successfully when project update succeeds`() {
         // Given
         val project = projectHelper()
+        every { validator.isValid(any()) }returns true
         every { projectRepository.updateProject(project) } returns "Updated Successfully"
         every { cashedUser.currentUser.id } returns "user_123"
 
diff --git a/src/test/kotlin/domain/usecase/task/ChangeTaskStateUseCaseTest.kt b/src/test/kotlin/domain/usecase/task/ChangeTaskStateUseCaseTest.kt
index 3b7655e..f1050a7 100644
--- a/src/test/kotlin/domain/usecase/task/ChangeTaskStateUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/task/ChangeTaskStateUseCaseTest.kt
@@ -7,6 +7,7 @@ import com.berlin.domain.model.Task
 import com.berlin.domain.model.user.User
 import com.berlin.domain.repository.TaskRepository
 import com.berlin.domain.usecase.audit_system.AddAuditLogUseCase
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.google.common.truth.Truth.assertThat
 import data.UserCache
 import io.mockk.*
@@ -20,6 +21,7 @@ class ChangeTaskStateUseCaseTest {
     private lateinit var addAuditLogUseCase: AddAuditLogUseCase
     private lateinit var userCache: UserCache
     private lateinit var changeTaskStateUseCase: ChangeTaskStateUseCase
+    private lateinit var validator: Validator
 
     private val creator = mockk<User>(relaxed = true)
 
@@ -38,6 +40,7 @@ class ChangeTaskStateUseCaseTest {
         taskRepository = mockk()
         addAuditLogUseCase = mockk(relaxUnitFun = true)
         userCache = mockk()
+        validator= mockk( relaxed = true)
 
         every { creator.id } returns "U1"
         every { userCache.currentUser } returns creator
@@ -52,7 +55,7 @@ class ChangeTaskStateUseCaseTest {
             )
         } just Runs
 
-        changeTaskStateUseCase = ChangeTaskStateUseCase(taskRepository, addAuditLogUseCase, userCache)
+        changeTaskStateUseCase = ChangeTaskStateUseCase(taskRepository, addAuditLogUseCase, userCache,validator)
     }
 
     private fun verifyAudit(taskId: String) {
@@ -68,6 +71,7 @@ class ChangeTaskStateUseCaseTest {
 
     @Test
     fun `result is success when state changes`() {
+        every { validator.isValid(any()) }returns true
         every { taskRepository.getTaskById("1") } returns existingTask
         every { taskRepository.updateTask(any()) } answers { firstArg() }
 
@@ -92,6 +96,7 @@ class ChangeTaskStateUseCaseTest {
 
     @Test
     fun `throws IllegalStateException when repository update fails`() {
+        every { validator.isValid(any()) }returns true
         every { taskRepository.getTaskById("1") } returns existingTask
         every { taskRepository.updateTask(any()) } throws IllegalStateException("boom")
 
diff --git a/src/test/kotlin/domain/usecase/task/CreateTaskUseCaseTest.kt b/src/test/kotlin/domain/usecase/task/CreateTaskUseCaseTest.kt
index 34f869f..8432ba6 100644
--- a/src/test/kotlin/domain/usecase/task/CreateTaskUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/task/CreateTaskUseCaseTest.kt
@@ -7,6 +7,7 @@ import com.berlin.domain.model.Task
 import com.berlin.domain.repository.TaskRepository
 import com.berlin.domain.usecase.audit_system.AddAuditLogUseCase
 import com.berlin.domain.usecase.utils.id_generator.IdGenerator
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.google.common.truth.Truth.assertThat
 import io.mockk.*
 import org.junit.jupiter.api.BeforeEach
@@ -21,6 +22,7 @@ class CreateTaskUseCaseTest {
     private lateinit var idGenerator: IdGenerator
     private lateinit var addAuditLogUseCase: AddAuditLogUseCase
     private lateinit var createTaskUseCase: CreateTaskUseCase
+    private lateinit var validator: Validator
 
     private val projectId = "P1"
     private val createByUserId = "U1"
@@ -31,7 +33,8 @@ class CreateTaskUseCaseTest {
         taskRepository = mockk(relaxed = true)
         idGenerator = mockk(relaxed = true)
         addAuditLogUseCase = mockk(relaxUnitFun = true)
-        createTaskUseCase = CreateTaskUseCase(taskRepository, idGenerator, addAuditLogUseCase)
+        validator= mockk(relaxed = true)
+        createTaskUseCase = CreateTaskUseCase(taskRepository, idGenerator, addAuditLogUseCase,validator)
     }
 
     @Test
@@ -48,7 +51,7 @@ class CreateTaskUseCaseTest {
             assignedToUserId = assignedToUserId,
             createByUserId = createByUserId
         )
-
+        every { validator.isValid(any()) }returns true
         every { idGenerator.generateId(trimmed, any(), any()) } returns generatedId
         every { taskRepository.getTaskById(generatedId) } returns newTask
         every { taskRepository.createTask(any()) } returns newTask
@@ -86,6 +89,7 @@ class CreateTaskUseCaseTest {
         val trimmed = rawTitle.trim()
         val existingId = "T999"
 
+        every { validator.isValid(any()) }returns true
         every { idGenerator.generateId(trimmed, any(), any()) } returns existingId
         every { taskRepository.getTaskById(existingId) } throws NoSuchElementException()
 
@@ -120,6 +124,7 @@ class CreateTaskUseCaseTest {
         val trimmed = rawTitle.trim()
         val generatedId = "T500"
 
+        every { validator.isValid(any()) }returns true
         every { idGenerator.generateId(trimmed, any(), any()) } returns generatedId
         every { taskRepository.getTaskById(generatedId) } returns Task(
             generatedId, projectId, trimmed, null, "TODO", assignedToUserId, createByUserId
diff --git a/src/test/kotlin/domain/usecase/task/DeleteTaskUseCaseTest.kt b/src/test/kotlin/domain/usecase/task/DeleteTaskUseCaseTest.kt
index af23f4e..65d12dc 100644
--- a/src/test/kotlin/domain/usecase/task/DeleteTaskUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/task/DeleteTaskUseCaseTest.kt
@@ -4,6 +4,7 @@ import com.berlin.domain.model.AuditLog
 import com.berlin.domain.model.user.User
 import com.berlin.domain.repository.TaskRepository
 import com.berlin.domain.usecase.audit_system.AddAuditLogUseCase
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.google.common.truth.Truth.assertThat
 import data.UserCache
 import io.mockk.*
@@ -17,6 +18,7 @@ class DeleteTaskUseCaseTest {
     private lateinit var addAuditLogUseCase: AddAuditLogUseCase
     private lateinit var userCache: UserCache
     private lateinit var deleteTaskUseCase: DeleteTaskUseCase
+    private lateinit var validator: Validator
 
     private lateinit var currentUser: User
 
@@ -25,6 +27,7 @@ class DeleteTaskUseCaseTest {
         taskRepository = mockk()
         addAuditLogUseCase = mockk(relaxUnitFun = true)
         userCache = mockk()
+        validator= mockk()
 
         currentUser = mockk(relaxed = true)
         every { currentUser.id } returns "U1"
@@ -39,11 +42,12 @@ class DeleteTaskUseCaseTest {
             )
         } just Runs
 
-        deleteTaskUseCase = DeleteTaskUseCase(taskRepository, addAuditLogUseCase, userCache)
+        deleteTaskUseCase = DeleteTaskUseCase(taskRepository, addAuditLogUseCase, userCache,validator)
     }
 
     @Test
     fun `returns Deleted when repository deletes task`() {
+        every { validator.isValid("T1") }returns true
         every { taskRepository.deleteTask("T1") } just Runs
 
         val result = deleteTaskUseCase("T1")
@@ -62,6 +66,7 @@ class DeleteTaskUseCaseTest {
 
     @Test
     fun `throws IllegalStateException when repository delete throws`() {
+        every { validator.isValid("T1") }returns true
         every { taskRepository.deleteTask("T1") } throws IllegalStateException("boom")
 
         assertThrows<IllegalStateException> {
diff --git a/src/test/kotlin/domain/usecase/task/GetTaskByIdUseCaseTest.kt b/src/test/kotlin/domain/usecase/task/GetTaskByIdUseCaseTest.kt
index 615184e..514bd4b 100644
--- a/src/test/kotlin/domain/usecase/task/GetTaskByIdUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/task/GetTaskByIdUseCaseTest.kt
@@ -3,6 +3,7 @@ package com.berlin.domain.usecase.task
 import com.berlin.domain.exception.InvalidTaskIdException
 import com.berlin.domain.model.Task
 import com.berlin.domain.repository.TaskRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.google.common.truth.Truth.assertThat
 import io.mockk.every
 import io.mockk.mockk
@@ -15,6 +16,7 @@ class GetTaskByIdUseCaseTest {
 
     private lateinit var taskRepository: TaskRepository
     private lateinit var getTaskByIdUseCase: GetTaskByIdUseCase
+    private lateinit var validator: Validator
 
     private val validId = "T1"
     private val stored = Task(
@@ -30,12 +32,14 @@ class GetTaskByIdUseCaseTest {
     @BeforeEach
     fun setUp() {
         taskRepository = mockk()
-        getTaskByIdUseCase = GetTaskByIdUseCase(taskRepository)
+        validator= mockk(relaxed = true)
+        getTaskByIdUseCase = GetTaskByIdUseCase(taskRepository,validator)
     }
 
     @Test
     fun `returns task when repository returns a task`() {
         // stub repo to return directly
+        every { validator.isValid(validId) }returns true
         every { taskRepository.getTaskById(validId) } returns stored
 
         val result = getTaskByIdUseCase(validId)
@@ -46,6 +50,7 @@ class GetTaskByIdUseCaseTest {
     @Test
     fun `throws repository exception when repo fails`() {
         val ex = IllegalStateException("boom")
+        every { validator.isValid(validId) }returns true
         every { taskRepository.getTaskById(validId) } throws ex
 
         assertThrows<IllegalStateException> {
diff --git a/src/test/kotlin/domain/usecase/task/GetTasksByProjectUseCaseTest.kt b/src/test/kotlin/domain/usecase/task/GetTasksByProjectUseCaseTest.kt
index 721a13d..eb9fe95 100644
--- a/src/test/kotlin/domain/usecase/task/GetTasksByProjectUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/task/GetTasksByProjectUseCaseTest.kt
@@ -3,6 +3,7 @@ package com.berlin.domain.usecase.task
 import com.berlin.domain.exception.InvalidProjectIdException
 import com.berlin.domain.model.Task
 import com.berlin.domain.repository.TaskRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.google.common.truth.Truth.assertThat
 import io.mockk.every
 import io.mockk.mockk
@@ -15,6 +16,7 @@ class GetTasksByProjectUseCaseTest {
 
     private lateinit var taskRepository: TaskRepository
     private lateinit var getTasksByProjectUseCase: GetTasksByProjectUseCase
+    private lateinit var validator: Validator
 
     private val task = Task(
         id = "1",
@@ -29,11 +31,13 @@ class GetTasksByProjectUseCaseTest {
     @BeforeEach
     fun setUp() {
         taskRepository = mockk()
-        getTasksByProjectUseCase = GetTasksByProjectUseCase(taskRepository)
+        validator= mockk(relaxed = true)
+        getTasksByProjectUseCase = GetTasksByProjectUseCase(taskRepository,validator)
     }
 
     @Test
     fun `returns tasks when repository returns non-empty list`() {
+        every { validator.isValid("P1") }returns true
         every { taskRepository.getTasksByProjectId("P1") } returns listOf(task)
 
         val result = getTasksByProjectUseCase("P1")
@@ -43,6 +47,7 @@ class GetTasksByProjectUseCaseTest {
 
     @Test
     fun `returns empty list when repository returns empty list`() {
+        every { validator.isValid("P1") }returns true
         every { taskRepository.getTasksByProjectId("P1") } returns emptyList()
 
         val result = getTasksByProjectUseCase("P1")
@@ -52,6 +57,7 @@ class GetTasksByProjectUseCaseTest {
 
     @Test
     fun `throws IllegalStateException when repository throws`() {
+        every { validator.isValid("P1") }returns true
         every { taskRepository.getTasksByProjectId("P1") } throws IllegalStateException("boom")
 
         assertThrows<IllegalStateException> {
diff --git a/src/test/kotlin/domain/usecase/task_state/CreateTaskStateUseCaseTest.kt b/src/test/kotlin/domain/usecase/task_state/CreateTaskStateUseCaseTest.kt
index ed9d4b1..8d94cf2 100644
--- a/src/test/kotlin/domain/usecase/task_state/CreateTaskStateUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/task_state/CreateTaskStateUseCaseTest.kt
@@ -5,6 +5,7 @@ import com.berlin.domain.exception.InvalidStateNameException
 import com.berlin.domain.model.TaskState
 import com.berlin.domain.repository.TaskStateRepository
 import com.berlin.domain.usecase.utils.id_generator.IdGeneratorImplementation
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.google.common.truth.Truth.assertThat
 import io.mockk.every
 import io.mockk.mockk
@@ -18,13 +19,14 @@ class CreateTaskStateUseCaseTest {
 
     private lateinit var createTaskStateUseCase: CreateTaskStateUseCase
     private val taskStateRepository: TaskStateRepository = mockk(relaxed = true)
+    private val validator: Validator = mockk(relaxed = true)
 
     @BeforeEach
     fun setup() {
         val idGenerator: IdGeneratorImplementation = mockk(relaxed = true)
         createTaskStateUseCase = CreateTaskStateUseCase(
             taskStateRepository,
-            idGenerator
+            idGenerator,validator
         )
     }
 
@@ -32,6 +34,7 @@ class CreateTaskStateUseCaseTest {
     fun `createNewState should return success when state created successfully`() {
         // Given
         val validState = TaskState(id = "S1", name = "TODO", projectId = "P1")
+        every { validator.isValid(any()) }returns true
         every { taskStateRepository.addState(any()) } returns "State created successfully"
         every { taskStateRepository.getStateById(any()) } returns mockk()
 
@@ -51,6 +54,7 @@ class CreateTaskStateUseCaseTest {
     fun `createNewState should throw exception when state creation fails`() {
         // Given
         val validState = TaskState(id = "S1", name = "S1", projectId = "1")
+        every { validator.isValid(any()) }returns true
         every { taskStateRepository.addState(any()) } throws InvalidStateException("can not add state")
         every { taskStateRepository.getStateById(any()) } returns mockk()
 
diff --git a/src/test/kotlin/domain/usecase/task_state/DeleteTaskStateUseCaseTest.kt b/src/test/kotlin/domain/usecase/task_state/DeleteTaskStateUseCaseTest.kt
index caf504d..bc20be7 100644
--- a/src/test/kotlin/domain/usecase/task_state/DeleteTaskStateUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/task_state/DeleteTaskStateUseCaseTest.kt
@@ -3,6 +3,7 @@ package com.berlin.domain.usecase.task_state
 import com.berlin.domain.exception.InvalidStateException
 import com.berlin.domain.exception.InvalidStateIdException
 import com.berlin.domain.repository.TaskStateRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.google.common.truth.Truth.assertThat
 import io.mockk.every
 import io.mockk.mockk
@@ -13,15 +14,17 @@ import kotlin.test.Test
 class DeleteTaskStateUseCaseTest {
     private lateinit var deleteTaskStateUseCase: DeleteTaskStateUseCase
     private val taskStateRepository: TaskStateRepository = mockk(relaxed = true)
+    private val validator: Validator = mockk(relaxed = true)
 
     @BeforeEach
     fun setup() {
-        deleteTaskStateUseCase = DeleteTaskStateUseCase(taskStateRepository)
+        deleteTaskStateUseCase = DeleteTaskStateUseCase(taskStateRepository,validator)
     }
 
     @Test
     fun `should return success when state is deleted successfully`() {
         // Given
+        every { validator.isValid(any()) }returns true
         every { taskStateRepository.deleteState(any()) } returns "Deleted Successfully"
         every { taskStateRepository.getStateById(any()) } returns mockk()
 
@@ -35,6 +38,7 @@ class DeleteTaskStateUseCaseTest {
     @Test
     fun `should return failure when state deletion fails`() {
         // Given
+        every { validator.isValid(any()) }returns true
         every { taskStateRepository.deleteState(any()) } returns "Deletion Failed"
         every { taskStateRepository.getStateById(any()) } returns mockk()
 
@@ -50,6 +54,7 @@ class DeleteTaskStateUseCaseTest {
     fun `should throw exception when state does not exist`() {
         // Given
         val stateId = "q2"
+        every { validator.isValid(any()) }returns true
         every { taskStateRepository.deleteState(any()) } throws InvalidStateException(stateId)
 
         // When & Then
@@ -60,6 +65,7 @@ class DeleteTaskStateUseCaseTest {
     @Test
     fun `should throw InvalidStateException when state does not exist`() {
         val stateId = "q2"
+        every { validator.isValid(stateId) }returns true
         every { taskStateRepository.deleteState(stateId) } throws InvalidStateException(stateId)
 
         assertThrows<InvalidStateException> {
diff --git a/src/test/kotlin/domain/usecase/task_state/GetAllTaskStatesByProjectIdUseCaseTest.kt b/src/test/kotlin/domain/usecase/task_state/GetAllTaskStatesByProjectIdUseCaseTest.kt
index fdcd453..eb28472 100644
--- a/src/test/kotlin/domain/usecase/task_state/GetAllTaskStatesByProjectIdUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/task_state/GetAllTaskStatesByProjectIdUseCaseTest.kt
@@ -3,6 +3,7 @@ package com.berlin.domain.usecase.task_state
 import com.berlin.domain.model.TaskState
 import com.berlin.domain.repository.ProjectRepository
 import com.berlin.domain.repository.TaskStateRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.google.common.truth.Truth.assertThat
 import io.mockk.every
 import io.mockk.mockk
@@ -17,12 +18,13 @@ class GetAllTaskStatesByProjectIdUseCaseTest {
     private lateinit var getAllTaskStatesByProjectIdUseCase: GetAllTaskStatesByProjectIdUseCase
     private val taskStateRepository: TaskStateRepository = mockk(relaxed = true)
     private val projectRepository: ProjectRepository = mockk(relaxed = true)
+    private val validator: Validator = mockk(relaxed = true)
 
     @BeforeEach
     fun setup() {
         getAllTaskStatesByProjectIdUseCase = GetAllTaskStatesByProjectIdUseCase(
             taskStateRepository,
-            projectRepository
+            projectRepository,validator
         )
     }
 
@@ -33,6 +35,7 @@ class GetAllTaskStatesByProjectIdUseCaseTest {
             TaskState(id = "S1", name = "Active", projectId = "P1"),
             TaskState(id = "S2", name = "Inactive", projectId = "P1")
         )
+        every { validator.isValid("P1") }returns true
         every { projectRepository.getProjectById("P1") } returns mockk()
         every { taskStateRepository.getStatesByProjectId("P1") } returns expectedStates
 
@@ -46,6 +49,7 @@ class GetAllTaskStatesByProjectIdUseCaseTest {
     @Test
     fun `should return empty when no states are found for the project`() {
         // Given
+        every { validator.isValid("P3") }returns true
         every { taskStateRepository.getStatesByProjectId("P3") } returns emptyList()
         // When
         val result = getAllTaskStatesByProjectIdUseCase("P3")
diff --git a/src/test/kotlin/domain/usecase/task_state/GetTaskStateByIdUseCaseTest.kt b/src/test/kotlin/domain/usecase/task_state/GetTaskStateByIdUseCaseTest.kt
index 07414dc..9b6f7ef 100644
--- a/src/test/kotlin/domain/usecase/task_state/GetTaskStateByIdUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/task_state/GetTaskStateByIdUseCaseTest.kt
@@ -3,6 +3,7 @@ package com.berlin.domain.usecase.task_state
 import com.berlin.domain.exception.StateNotFoundException
 import com.berlin.domain.model.TaskState
 import com.berlin.domain.repository.TaskStateRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.google.common.truth.Truth.assertThat
 import io.mockk.every
 import io.mockk.mockk
@@ -16,17 +17,19 @@ class GetTaskStateByIdUseCaseTest {
 
     private lateinit var getTaskStateByIdUseCase: GetTaskStateByIdUseCase
     private lateinit var taskStateRepository: TaskStateRepository
+    private val validator: Validator = mockk(relaxed = true)
 
     @BeforeEach
     fun setup() {
         taskStateRepository = mockk()
-        getTaskStateByIdUseCase = GetTaskStateByIdUseCase(taskStateRepository)
+        getTaskStateByIdUseCase = GetTaskStateByIdUseCase(taskStateRepository,validator)
     }
 
     @Test
     fun `should return state when valid state id exists`() {
         // Given
         val expectedState = TaskState(id = "S1", name = "Active", projectId = "P1")
+        every { validator.isValid("S1") }returns true
         every { taskStateRepository.getStateById("S1") } returns expectedState
 
         // When
@@ -40,6 +43,7 @@ class GetTaskStateByIdUseCaseTest {
     fun `should throw exception when state id does not exist`() {
         // Given
         val input = "S2"
+        every { validator.isValid(any()) }returns true
         every { taskStateRepository.getStateById(any()) } throws StateNotFoundException(input)
 
         // When & Then
diff --git a/src/test/kotlin/domain/usecase/task_state/GetTaskStateByTaskIdUseCaseTest.kt b/src/test/kotlin/domain/usecase/task_state/GetTaskStateByTaskIdUseCaseTest.kt
index a126b11..7b740e7 100644
--- a/src/test/kotlin/domain/usecase/task_state/GetTaskStateByTaskIdUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/task_state/GetTaskStateByTaskIdUseCaseTest.kt
@@ -3,6 +3,7 @@ package com.berlin.domain.usecase.task_state
 import com.berlin.domain.model.TaskState
 import com.berlin.domain.repository.TaskRepository
 import com.berlin.domain.repository.TaskStateRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.google.common.truth.Truth.assertThat
 import io.mockk.every
 import io.mockk.mockk
@@ -17,16 +18,19 @@ class GetTaskStateByTaskIdUseCaseTest {
     private lateinit var getTaskStateByTaskIdUseCase: GetTaskStateByTaskIdUseCase
     private val taskStateRepository: TaskStateRepository = mockk(relaxed = true)
     private val taskRepository: TaskRepository = mockk(relaxed = true)
+    private val validator: Validator = mockk(relaxed = true)
+
 
     @BeforeEach
     fun setup() {
-        getTaskStateByTaskIdUseCase = GetTaskStateByTaskIdUseCase(taskStateRepository, taskRepository)
+        getTaskStateByTaskIdUseCase = GetTaskStateByTaskIdUseCase(taskStateRepository, taskRepository,validator)
     }
 
     @Test
     fun `should return state when task id exists`() {
         // Given
         val expectedState = TaskState(id = "S1", name = "Active", projectId = "P1")
+        every { validator.isValid("T1") }returns true
         every { taskRepository.getTaskById("T1") } returns mockk()
         every { taskStateRepository.getStateByTaskId("T1") } returns expectedState
 
diff --git a/src/test/kotlin/domain/usecase/task_state/GetTasksByTaskStateIdUseCaseTest.kt b/src/test/kotlin/domain/usecase/task_state/GetTasksByTaskStateIdUseCaseTest.kt
index 9523ec6..b1c66f7 100644
--- a/src/test/kotlin/domain/usecase/task_state/GetTasksByTaskStateIdUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/task_state/GetTasksByTaskStateIdUseCaseTest.kt
@@ -2,6 +2,7 @@ package com.berlin.domain.usecase.task_state
 
 import com.berlin.domain.model.Task
 import com.berlin.domain.repository.TaskStateRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.google.common.truth.Truth.assertThat
 import io.mockk.every
 import io.mockk.mockk
@@ -15,6 +16,7 @@ class GetTasksByTaskStateIdUseCaseTest {
 
     private lateinit var getTasksByTaskStateIdUseCase: GetTasksByTaskStateIdUseCase
     private val taskStateRepository: TaskStateRepository = mockk(relaxed = true)
+    private val validator: Validator = mockk(relaxed = true)
 
     private val task = Task(
         id = "T1",
@@ -28,13 +30,14 @@ class GetTasksByTaskStateIdUseCaseTest {
 
     @BeforeEach
     fun setup() {
-        getTasksByTaskStateIdUseCase = GetTasksByTaskStateIdUseCase(taskStateRepository)
+        getTasksByTaskStateIdUseCase = GetTasksByTaskStateIdUseCase(taskStateRepository,validator)
     }
 
     @Test
     fun `should return tasks when tasks are found for the state`() {
         // Given
         val expectedTasks = listOf(task)
+        every { validator.isValid("S1") }returns true
         every { taskStateRepository.getTasksByStateId("S1") } returns expectedTasks
         every { taskStateRepository.getStateById("S1") } returns mockk()
 
@@ -48,6 +51,7 @@ class GetTasksByTaskStateIdUseCaseTest {
     @Test
     fun `should throw exception when no tasks are found for the state`() {
         // Given
+        every { validator.isValid("S2") }returns true
         every { taskStateRepository.getTasksByStateId("S2") } returns null
         every { taskStateRepository.getStateById("S2") } returns mockk()
 
diff --git a/src/test/kotlin/domain/usecase/task_state/UpdateTaskStateUseCaseTest.kt b/src/test/kotlin/domain/usecase/task_state/UpdateTaskStateUseCaseTest.kt
index e1d370d..4123c7e 100644
--- a/src/test/kotlin/domain/usecase/task_state/UpdateTaskStateUseCaseTest.kt
+++ b/src/test/kotlin/domain/usecase/task_state/UpdateTaskStateUseCaseTest.kt
@@ -2,6 +2,7 @@ package com.berlin.domain.usecase.task_state
 
 import com.berlin.domain.model.TaskState
 import com.berlin.domain.repository.TaskStateRepository
+import com.berlin.domain.usecase.utils.validation.Validator
 import com.google.common.truth.Truth.assertThat
 import io.mockk.every
 import io.mockk.mockk
@@ -15,16 +16,18 @@ class UpdateTaskStateUseCaseTest {
 
     private lateinit var updateTaskStateUseCase: UpdateTaskStateUseCase
     private val taskStateRepository: TaskStateRepository = mockk(relaxed = true)
+    private val validator: Validator = mockk(relaxed = true)
 
     @BeforeEach
     fun setup() {
-        updateTaskStateUseCase = UpdateTaskStateUseCase(taskStateRepository)
+        updateTaskStateUseCase = UpdateTaskStateUseCase(taskStateRepository,validator)
     }
 
     @Test
     fun `should return success when state update succeeds`() {
         // Given
         val state = TaskState(id = "S1", name = "Active", projectId = "P1")
+        every { validator.isValid(any()) }returns true
         every { taskStateRepository.updateState(state) } returns "Updated Successfully"
 
         // When
@@ -38,6 +41,7 @@ class UpdateTaskStateUseCaseTest {
     fun `should return exception when state update fails`() {
         // Given
         val state = TaskState(id = "S2", name = "Inactive", projectId = "P2")
+        every { validator.isValid(any()) }returns true
         every { taskStateRepository.updateState(state) } throws Exception()
 
         // When & Then