diff --git a/pom.xml b/pom.xml index 53ab393..f304050 100644 --- a/pom.xml +++ b/pom.xml @@ -66,6 +66,12 @@ ${version.junit} test + + org.mockito + mockito-core + ${version.mockito} + test + org.projectlombok diff --git a/source/backend/challenge/modules/task/dtos/ITaskDtoFactory.java b/source/backend/challenge/modules/task/dtos/ITaskDtoFactory.java new file mode 100644 index 0000000..8fd5273 --- /dev/null +++ b/source/backend/challenge/modules/task/dtos/ITaskDtoFactory.java @@ -0,0 +1,5 @@ +package backend.challenge.modules.task.dtos; + +public interface ITaskDtoFactory { + public TaskDTO build(String title, String description); +} diff --git a/source/backend/challenge/modules/task/dtos/ITaskProgressDtoFactory.java b/source/backend/challenge/modules/task/dtos/ITaskProgressDtoFactory.java new file mode 100644 index 0000000..c39a528 --- /dev/null +++ b/source/backend/challenge/modules/task/dtos/ITaskProgressDtoFactory.java @@ -0,0 +1,6 @@ +package backend.challenge.modules.task.dtos; + +public interface ITaskProgressDtoFactory { + + public TaskProgressDTO build(Long taskId, int progress); +} diff --git a/source/backend/challenge/modules/task/dtos/TaskDtoFactory.java b/source/backend/challenge/modules/task/dtos/TaskDtoFactory.java new file mode 100644 index 0000000..9a4ae81 --- /dev/null +++ b/source/backend/challenge/modules/task/dtos/TaskDtoFactory.java @@ -0,0 +1,12 @@ +package backend.challenge.modules.task.dtos; + +public class TaskDtoFactory implements ITaskDtoFactory{ + + @Override + public TaskDTO build(String title, String description) { + TaskDTO taskDTO = TaskDTO.create(); + taskDTO.setTitle(title); + taskDTO.setDescription(description); + return taskDTO; + } +} diff --git a/source/backend/challenge/modules/task/dtos/TaskProgressDtoFactory.java b/source/backend/challenge/modules/task/dtos/TaskProgressDtoFactory.java new file mode 100644 index 0000000..53e775c --- /dev/null +++ b/source/backend/challenge/modules/task/dtos/TaskProgressDtoFactory.java @@ -0,0 +1,12 @@ +package backend.challenge.modules.task.dtos; + +public class TaskProgressDtoFactory implements ITaskProgressDtoFactory{ + + @Override + public TaskProgressDTO build(Long taskId, int progress) { + TaskProgressDTO taskProgressDTO = TaskProgressDTO.create(); + taskProgressDTO.setId(taskId); + taskProgressDTO.setProgress(progress); + return taskProgressDTO; + } +} diff --git a/source/backend/challenge/modules/task/infra/http/controllers/TaskController.java b/source/backend/challenge/modules/task/infra/http/controllers/TaskController.java index 6a06a52..28f2a39 100644 --- a/source/backend/challenge/modules/task/infra/http/controllers/TaskController.java +++ b/source/backend/challenge/modules/task/infra/http/controllers/TaskController.java @@ -1,5 +1,8 @@ package backend.challenge.modules.task.infra.http.controllers; +import backend.challenge.modules.task.dtos.TaskDtoFactory; +import backend.challenge.modules.task.dtos.TaskProgressDtoFactory; +import backend.challenge.modules.task.infra.http.views.TaskProgressView; import backend.challenge.modules.task.infra.http.views.TaskView; import backend.challenge.modules.task.models.Task; import backend.challenge.modules.task.services.*; @@ -17,40 +20,42 @@ public class TaskController { private final IRetrieveAllTasksService retrieveAllTasksService; private final IRetrieveTaskByIdService retrieveTaskByIdService; private final IUpdateTaskService updateTaskService; + private final IUpdateTaskProgressService updateTaskProgressService; @Inject public TaskController( - final ICreateTaskService createTaskService, - final IDeleteTaskService deleteTaskService, - final IRetrieveAllTasksService retrieveAllTasksService - ) { + final ICreateTaskService createTaskService, + final IDeleteTaskService deleteTaskService, + final IRetrieveAllTasksService retrieveAllTasksService, + final IRetrieveTaskByIdService retrieveTaskByIdService, + final IUpdateTaskService updateTaskService, + final IUpdateTaskProgressService updateTaskProgressService + ) { this.createTaskService = createTaskService; this.deleteTaskService = deleteTaskService; this.retrieveAllTasksService = retrieveAllTasksService; - this.retrieveTaskByIdService = null; - this.updateTaskService = null; - } + this.retrieveTaskByIdService = retrieveTaskByIdService; + this.updateTaskService = updateTaskService; + this.updateTaskProgressService = updateTaskProgressService; + } @GET public Response show() { // TODO: Rota que lista todas as tarefas - - return DefaultResponse.ok().entity("Hello world"); + return DefaultResponse.ok().entity(retrieveAllTasksService.execute()); } @GET @Path("single/{taskId}") public Response index(@PathParam("taskId") Long taskId) { // TODO: A rota deve retornar somente a tarefa a qual o id corresponder - - return DefaultResponse.ok().entity("Hello world"); + return retrieveTaskByIdService.execute(taskId); } @POST public Response create(TaskView task) { // TODO: A rota deve receber title e description, sendo o `title` o título da tarefa e `description` uma descrição da tarefa. - - return DefaultResponse.ok().entity("Hello world"); + return createTaskService.execute(new TaskDtoFactory().build(task.getTitle(), task.getDescription())); } @PUT @@ -60,16 +65,25 @@ public Response update(@PathParam("taskId") Long taskId, Task task) { TODO: A rota deve alterar apenas o title e description da tarefa que possua o id igual ao id correspondente nos parâmetros da rota. */ + return updateTaskService.execute(taskId, task); + } - return DefaultResponse.ok().entity("Hello world"); + @PUT + @Path("progress/single/{taskId}") + public Response updateProgress(@PathParam("taskId") Long taskId, TaskProgressView taskProgressView) { + /* + TODO: A rota deve alterar apenas o title e description da tarefa + que possua o id igual ao id correspondente nos parâmetros da rota. + */ + return updateTaskProgressService.execute(new TaskProgressDtoFactory().build(taskId, taskProgressView.getProgress())); } @DELETE @Path("single/{taskId}") public Response delete(@PathParam("taskId") Long taskId) { // TODO: A rota deve deletar a tarefa com o id correspondente nos parâmetros da rota - - return DefaultResponse.ok().entity("Hello world"); + deleteTaskService.execute(taskId); + return DefaultResponse.ok().entity("Tarefa removida com sucesso"); } } diff --git a/source/backend/challenge/modules/task/models/ITaskFactory.java b/source/backend/challenge/modules/task/models/ITaskFactory.java new file mode 100644 index 0000000..a7871a4 --- /dev/null +++ b/source/backend/challenge/modules/task/models/ITaskFactory.java @@ -0,0 +1,8 @@ +package backend.challenge.modules.task.models; + +import backend.challenge.modules.task.dtos.TaskDTO; + +public interface ITaskFactory { + + public Task build(TaskDTO taskDTO); +} diff --git a/source/backend/challenge/modules/task/models/Task.java b/source/backend/challenge/modules/task/models/Task.java index 123f10c..f1d750e 100644 --- a/source/backend/challenge/modules/task/models/Task.java +++ b/source/backend/challenge/modules/task/models/Task.java @@ -1,6 +1,7 @@ package backend.challenge.modules.task.models; import backend.challenge.modules.task.enums.TaskStatus; +import com.fasterxml.jackson.annotation.JsonFormat; import lombok.Getter; import lombok.NoArgsConstructor; import lombok.RequiredArgsConstructor; @@ -18,6 +19,7 @@ public class Task { private String description; private int progress; private TaskStatus status; + @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd") private Date createdAt; } diff --git a/source/backend/challenge/modules/task/models/TaskFactory.java b/source/backend/challenge/modules/task/models/TaskFactory.java new file mode 100644 index 0000000..c34a86e --- /dev/null +++ b/source/backend/challenge/modules/task/models/TaskFactory.java @@ -0,0 +1,22 @@ +package backend.challenge.modules.task.models; + +import backend.challenge.modules.task.dtos.TaskDTO; +import backend.challenge.modules.task.enums.TaskStatus; + +import java.util.Date; +import java.util.UUID; + +public class TaskFactory implements ITaskFactory{ + + @Override + public Task build(TaskDTO taskDTO) { + Task task = new Task(); + task.setId(Math.abs(UUID.randomUUID().getLeastSignificantBits())); + task.setTitle(taskDTO.getTitle()); + task.setDescription(taskDTO.getDescription()); + task.setProgress(0); + task.setStatus(TaskStatus.PROGRESS); + task.setCreatedAt(new Date()); + return task; + } +} diff --git a/source/backend/challenge/modules/task/repositories/ITaskRepository.java b/source/backend/challenge/modules/task/repositories/ITaskRepository.java index 527450a..ea46385 100644 --- a/source/backend/challenge/modules/task/repositories/ITaskRepository.java +++ b/source/backend/challenge/modules/task/repositories/ITaskRepository.java @@ -11,6 +11,7 @@ public interface ITaskRepository { List show(); Task create(TaskDTO taskDTO); Task update(Task task); + Task updateProgress(Task task); void delete(Long taskId); } diff --git a/source/backend/challenge/modules/task/repositories/TaskRepository.java b/source/backend/challenge/modules/task/repositories/TaskRepository.java index c47c8fd..f0451b7 100644 --- a/source/backend/challenge/modules/task/repositories/TaskRepository.java +++ b/source/backend/challenge/modules/task/repositories/TaskRepository.java @@ -2,45 +2,68 @@ import backend.challenge.modules.task.dtos.TaskDTO; import backend.challenge.modules.task.models.Task; +import backend.challenge.modules.task.models.TaskFactory; import javax.inject.Singleton; +import java.util.ArrayList; import java.util.List; +import java.util.stream.Collectors; @Singleton public class TaskRepository implements ITaskRepository { + List taskList = new ArrayList<>(); + @Override - public Task index(final Long taskId) { + public Task index(final Long taskId){ // TODO: Criar método responsável por retornar tarefa por id - - return null; + List retrivedtask = taskList.stream().filter(task -> task.getId().equals(taskId)).collect(Collectors.toList()); + Task task = null; + if (!retrivedtask.isEmpty()) { + task = retrivedtask.get(0); + } + return task; } @Override public List show() { // TODO: Criar método responsável por retornar todas as tarefas - - return null; + return taskList; } @Override public Task create(final TaskDTO taskDTO) { // TODO: Criar método responsável por criar uma tarefa - - return null; + Task task = null; + if (taskDTO.getTitle().trim().isEmpty()) { + return task; + } + task = new TaskFactory().build(taskDTO); + taskList.add(task); + return task; } @Override public Task update(final Task task) { - // TODO: Criar método responsável por atualizar uma tarefa + // TODO: Criar método responsável por atualizar progresso e status da tarefa + Task retrivedTask = this.index(task.getId()); + retrivedTask.setTitle(task.getTitle()); + retrivedTask.setDescription(task.getDescription()); + return retrivedTask; + } - return null; + @Override + public Task updateProgress(Task task) { + Task retrivedTask = this.index(task.getId()); + retrivedTask.setProgress(task.getProgress()); + retrivedTask.setStatus(task.getStatus()); + return retrivedTask; } @Override public void delete(final Long taskId) { // TODO: Criar método responsável por deletar tarefa por id - + Task task = this.index(taskId); + taskList.remove(task); } - } diff --git a/source/backend/challenge/modules/task/services/CreateTaskService.java b/source/backend/challenge/modules/task/services/CreateTaskService.java index 46b144b..8c505a2 100644 --- a/source/backend/challenge/modules/task/services/CreateTaskService.java +++ b/source/backend/challenge/modules/task/services/CreateTaskService.java @@ -3,6 +3,7 @@ import backend.challenge.modules.task.dtos.TaskDTO; import backend.challenge.modules.task.models.Task; import backend.challenge.modules.task.repositories.ITaskRepository; +import kikaha.urouting.api.DefaultResponse; import javax.inject.Inject; import javax.inject.Singleton; @@ -18,10 +19,12 @@ public CreateTaskService(final ITaskRepository taskRepository) { } @Override - public Task execute(TaskDTO taskDTO) { + public DefaultResponse execute(TaskDTO taskDTO) { // TODO: Criar serviço responsável por criar uma tarefa - - return null; + Task task = taskRepository.create(taskDTO); + if (task == null) { + return DefaultResponse.notModified().entity("Titulo não pode ser vazio"); + } + return DefaultResponse.ok().entity(task); } - } diff --git a/source/backend/challenge/modules/task/services/DeleteTaskService.java b/source/backend/challenge/modules/task/services/DeleteTaskService.java index c957d70..e3118d8 100644 --- a/source/backend/challenge/modules/task/services/DeleteTaskService.java +++ b/source/backend/challenge/modules/task/services/DeleteTaskService.java @@ -18,6 +18,7 @@ public DeleteTaskService(final ITaskRepository taskRepository) { @Override public void execute(Long taskId) { // TODO: Criar serviço responsável por deletar a tarefa + taskRepository.delete(taskId); } } diff --git a/source/backend/challenge/modules/task/services/ICreateTaskService.java b/source/backend/challenge/modules/task/services/ICreateTaskService.java index 33b7d7b..0cde901 100644 --- a/source/backend/challenge/modules/task/services/ICreateTaskService.java +++ b/source/backend/challenge/modules/task/services/ICreateTaskService.java @@ -1,10 +1,10 @@ package backend.challenge.modules.task.services; import backend.challenge.modules.task.dtos.TaskDTO; -import backend.challenge.modules.task.models.Task; +import kikaha.urouting.api.DefaultResponse; public interface ICreateTaskService { - Task execute(TaskDTO taskDTO); + DefaultResponse execute(TaskDTO taskDTO); } diff --git a/source/backend/challenge/modules/task/services/IRetrieveTaskByIdService.java b/source/backend/challenge/modules/task/services/IRetrieveTaskByIdService.java index 192e28c..333760c 100644 --- a/source/backend/challenge/modules/task/services/IRetrieveTaskByIdService.java +++ b/source/backend/challenge/modules/task/services/IRetrieveTaskByIdService.java @@ -1,9 +1,9 @@ package backend.challenge.modules.task.services; -import backend.challenge.modules.task.models.Task; +import kikaha.urouting.api.DefaultResponse; public interface IRetrieveTaskByIdService { - Task execute(Long taskId); + DefaultResponse execute(Long taskId); } diff --git a/source/backend/challenge/modules/task/services/IUpdateTaskProgressService.java b/source/backend/challenge/modules/task/services/IUpdateTaskProgressService.java index 133b794..fb80de9 100644 --- a/source/backend/challenge/modules/task/services/IUpdateTaskProgressService.java +++ b/source/backend/challenge/modules/task/services/IUpdateTaskProgressService.java @@ -1,10 +1,10 @@ package backend.challenge.modules.task.services; import backend.challenge.modules.task.dtos.TaskProgressDTO; -import backend.challenge.modules.task.models.Task; +import kikaha.urouting.api.DefaultResponse; public interface IUpdateTaskProgressService { - Task execute(TaskProgressDTO taskProgressDTO); + DefaultResponse execute(TaskProgressDTO taskProgressDTO); } diff --git a/source/backend/challenge/modules/task/services/IUpdateTaskService.java b/source/backend/challenge/modules/task/services/IUpdateTaskService.java index 3da8340..5a953fd 100644 --- a/source/backend/challenge/modules/task/services/IUpdateTaskService.java +++ b/source/backend/challenge/modules/task/services/IUpdateTaskService.java @@ -1,9 +1,10 @@ package backend.challenge.modules.task.services; import backend.challenge.modules.task.models.Task; +import kikaha.urouting.api.DefaultResponse; public interface IUpdateTaskService { - Task execute(Task task); + DefaultResponse execute(Long taskId, Task task); } diff --git a/source/backend/challenge/modules/task/services/RetrieveAllTasksService.java b/source/backend/challenge/modules/task/services/RetrieveAllTasksService.java index 52a4149..db6a388 100644 --- a/source/backend/challenge/modules/task/services/RetrieveAllTasksService.java +++ b/source/backend/challenge/modules/task/services/RetrieveAllTasksService.java @@ -20,8 +20,7 @@ public RetrieveAllTasksService(final ITaskRepository taskRepository) { @Override public List execute() { // TODO: Criar serviço responsável por recuperar todas as tarefas - - return null; + return taskRepository.show(); } } diff --git a/source/backend/challenge/modules/task/services/RetriveTaskByIdService.java b/source/backend/challenge/modules/task/services/RetriveTaskByIdService.java new file mode 100644 index 0000000..44aff39 --- /dev/null +++ b/source/backend/challenge/modules/task/services/RetriveTaskByIdService.java @@ -0,0 +1,28 @@ +package backend.challenge.modules.task.services; + +import backend.challenge.modules.task.models.Task; +import backend.challenge.modules.task.repositories.ITaskRepository; +import kikaha.urouting.api.DefaultResponse; + +import javax.inject.Inject; +import javax.inject.Singleton; + +@Singleton +public class RetriveTaskByIdService implements IRetrieveTaskByIdService { + + private final ITaskRepository taskRepository; + + @Inject + public RetriveTaskByIdService(ITaskRepository taskRepository) { + this.taskRepository = taskRepository; + } + + @Override + public DefaultResponse execute(Long taskId) { + final Task retrivedTask = taskRepository.index(taskId); + if(retrivedTask == null) { + return DefaultResponse.notFound().statusCode(404); + } + return DefaultResponse.ok().entity(retrivedTask); + } +} diff --git a/source/backend/challenge/modules/task/services/UpdateTaskProgressService.java b/source/backend/challenge/modules/task/services/UpdateTaskProgressService.java new file mode 100644 index 0000000..4795b5d --- /dev/null +++ b/source/backend/challenge/modules/task/services/UpdateTaskProgressService.java @@ -0,0 +1,54 @@ +package backend.challenge.modules.task.services; + +import backend.challenge.modules.task.dtos.TaskProgressDTO; +import backend.challenge.modules.task.enums.TaskStatus; +import backend.challenge.modules.task.models.Task; +import backend.challenge.modules.task.repositories.ITaskRepository; +import kikaha.urouting.api.DefaultResponse; + +import javax.inject.Inject; +import javax.inject.Singleton; + +@Singleton +public class UpdateTaskProgressService implements IUpdateTaskProgressService{ + + private final ITaskRepository taskRepository; + private int LIMIT_PROGRESS = 100; + private int INITIAL_PROGRESS = 0; + + @Inject + public UpdateTaskProgressService(ITaskRepository taskRepository) { + this.taskRepository = taskRepository; + } + + @Override + public DefaultResponse execute(TaskProgressDTO taskProgressDTO) { + final Task retrivedTask = taskRepository.index(taskProgressDTO.getId()); + if(retrivedTask == null) { + return DefaultResponse.notFound().statusCode(404); + } + this.changeProgress(retrivedTask, taskProgressDTO.getProgress()); + this.changeStatus(retrivedTask); + Task updatedTask = taskRepository.updateProgress(retrivedTask); + return DefaultResponse.ok().entity(updatedTask); + } + + private void changeProgress(Task task, int progress) { + int taskProgress = 0; + if (progress > INITIAL_PROGRESS) { + taskProgress = progress; + } + if (progress > LIMIT_PROGRESS) { + taskProgress = LIMIT_PROGRESS; + } + task.setProgress(taskProgress); + } + + private void changeStatus(Task task) { + if(task.getProgress() == LIMIT_PROGRESS) { + task.setStatus(TaskStatus.COMPLETE); + }else { + task.setStatus(TaskStatus.PROGRESS); + } + } +} diff --git a/source/backend/challenge/modules/task/services/UpdateTaskService.java b/source/backend/challenge/modules/task/services/UpdateTaskService.java new file mode 100644 index 0000000..6567138 --- /dev/null +++ b/source/backend/challenge/modules/task/services/UpdateTaskService.java @@ -0,0 +1,30 @@ +package backend.challenge.modules.task.services; + +import backend.challenge.modules.task.models.Task; +import backend.challenge.modules.task.repositories.ITaskRepository; +import kikaha.urouting.api.DefaultResponse; + +import javax.inject.Inject; +import javax.inject.Singleton; + +@Singleton +public class UpdateTaskService implements IUpdateTaskService { + + private final ITaskRepository taskRepository; + + @Inject + public UpdateTaskService(ITaskRepository taskRepository) { + this.taskRepository = taskRepository; + } + + @Override + public DefaultResponse execute(Long taskId, Task task) { + final Task retrivedTask = taskRepository.index(taskId); + if(retrivedTask == null) { + return DefaultResponse.notFound().statusCode(404); + } + retrivedTask.setTitle(task.getTitle()); + retrivedTask.setDescription(task.getDescription()); + return DefaultResponse.ok().entity(taskRepository.update(retrivedTask)); + } +} diff --git a/tests/backend/challenge/modules/task/services/CreateTaskServiceTest.java b/tests/backend/challenge/modules/task/services/CreateTaskServiceTest.java index 684dc44..6fa9132 100644 --- a/tests/backend/challenge/modules/task/services/CreateTaskServiceTest.java +++ b/tests/backend/challenge/modules/task/services/CreateTaskServiceTest.java @@ -1,10 +1,14 @@ package backend.challenge.modules.task.services; +import backend.challenge.modules.task.dtos.TaskDTO; +import backend.challenge.modules.task.dtos.TaskDtoFactory; +import backend.challenge.modules.task.models.Task; import backend.challenge.modules.task.repositories.ITaskRepository; import backend.challenge.modules.task.repositories.TaskRepository; import kikaha.core.test.KikahaRunner; +import kikaha.urouting.api.DefaultResponse; +import org.junit.Assert; import org.junit.Before; -import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; @@ -16,7 +20,6 @@ public class CreateTaskServiceTest { @Before public void init() { final ITaskRepository taskRepository = new TaskRepository(); - createTaskService = new CreateTaskService(taskRepository); } @@ -24,9 +27,23 @@ public void init() { public void shouldBeAbleToCreateANewTask() { // TODO: Para que esse teste passe, sua aplicação deve permitir que // uma tarefa seja criado, e retorne um json com a tarefa criada. + final String expectedTitle = "Compras"; + final String expectedDescription = "Comprar presente para minha esposa"; + TaskDTO taskDTO = new TaskDtoFactory().build(expectedTitle, expectedDescription); + DefaultResponse defaultResponse = createTaskService.execute(taskDTO); + Task task = (Task) defaultResponse.entity(); + Assert.assertNotNull(task.getId()); + Assert.assertEquals(task.getTitle(), expectedTitle); + Assert.assertEquals(task.getDescription(), expectedDescription); } - - - + @Test + public void ShouldNotBeAbleToCreateNewTaskWithEmptyTitle() { + final String expectedTitle = ""; + final String expectedDescription = "Comprar presente para minha esposa"; + TaskDTO taskDTO = new TaskDtoFactory().build(expectedTitle, expectedDescription); + DefaultResponse defaultResponse = createTaskService.execute(taskDTO); + final String expectedMessage = "Titulo não pode ser vazio"; + Assert.assertTrue(defaultResponse.entity().toString().contains(expectedMessage)); + } } \ No newline at end of file diff --git a/tests/backend/challenge/modules/task/services/DeleteTaskServiceTest.java b/tests/backend/challenge/modules/task/services/DeleteTaskServiceTest.java index 93497a5..59cc390 100644 --- a/tests/backend/challenge/modules/task/services/DeleteTaskServiceTest.java +++ b/tests/backend/challenge/modules/task/services/DeleteTaskServiceTest.java @@ -1,5 +1,7 @@ package backend.challenge.modules.task.services; +import backend.challenge.modules.task.enums.TaskStatus; +import backend.challenge.modules.task.models.Task; import backend.challenge.modules.task.repositories.ITaskRepository; import backend.challenge.modules.task.repositories.TaskRepository; import kikaha.core.test.KikahaRunner; @@ -7,22 +9,36 @@ import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; + +import java.util.Date; + +import static org.mockito.Matchers.anyLong; +import static org.mockito.Matchers.anyObject; +import static org.mockito.Mockito.*; @RunWith( KikahaRunner.class ) public class DeleteTaskServiceTest { private IDeleteTaskService deleteTaskService; + @Mock + private ITaskRepository taskRepository = new TaskRepository(); + @Before public void init() { - final ITaskRepository taskRepository = new TaskRepository(); - + MockitoAnnotations.initMocks(this); deleteTaskService = new DeleteTaskService(taskRepository); } @Test public void shouldBeAbleToDeleteTaskById() { // TODO: Para que esse teste passe, sua aplicação deve permitir que tarefas sejam deletadas por id. + final Long taskId = 8567032865818388301L; + deleteTaskService.execute(taskId); + Mockito.verify(taskRepository, times(1)).delete(taskId); } diff --git a/tests/backend/challenge/modules/task/services/RetrieveAllTasksServiceTest.java b/tests/backend/challenge/modules/task/services/RetrieveAllTasksServiceTest.java index 68f0012..9589b4e 100644 --- a/tests/backend/challenge/modules/task/services/RetrieveAllTasksServiceTest.java +++ b/tests/backend/challenge/modules/task/services/RetrieveAllTasksServiceTest.java @@ -1,23 +1,41 @@ package backend.challenge.modules.task.services; +import backend.challenge.modules.task.dtos.TaskDTO; +import backend.challenge.modules.task.dtos.TaskDtoFactory; +import backend.challenge.modules.task.models.Task; +import backend.challenge.modules.task.models.TaskFactory; import backend.challenge.modules.task.repositories.ITaskRepository; import backend.challenge.modules.task.repositories.TaskRepository; import kikaha.core.test.KikahaRunner; +import org.junit.Assert; import org.junit.Before; -import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.ArrayList; +import java.util.List; + +import static org.mockito.Mockito.when; @RunWith( KikahaRunner.class ) public class RetrieveAllTasksServiceTest { private IRetrieveAllTasksService retrieveAllTasksService; + @Mock + final ITaskRepository taskRepository = new TaskRepository(); + List taskList = new ArrayList<>(); + @Before public void init() { - final ITaskRepository taskRepository = new TaskRepository(); - + MockitoAnnotations.initMocks(this); retrieveAllTasksService = new RetrieveAllTasksService(taskRepository); + for (int i = 0; i < 5; i++) { + TaskDTO taskDTO = new TaskDtoFactory().build("tarefa"+i, ""); + taskList.add(new TaskFactory().build(taskDTO)); + } } @Test @@ -26,6 +44,8 @@ public void shouldBeAbleToListTheTasks() { TODO: Para que esse teste passe, sua aplicação deve permitir que seja retornado um array com todas as tarefas que foram criadas até o momento. */ + when(taskRepository.show()).thenReturn(taskList); + Assert.assertEquals(retrieveAllTasksService.execute().size(), 5); } } \ No newline at end of file diff --git a/tests/backend/challenge/modules/task/services/RetrieveTaskByIdServiceTest.java b/tests/backend/challenge/modules/task/services/RetrieveTaskByIdServiceTest.java index eb96b15..9111cab 100644 --- a/tests/backend/challenge/modules/task/services/RetrieveTaskByIdServiceTest.java +++ b/tests/backend/challenge/modules/task/services/RetrieveTaskByIdServiceTest.java @@ -1,24 +1,54 @@ package backend.challenge.modules.task.services; +import backend.challenge.modules.task.enums.TaskStatus; +import backend.challenge.modules.task.models.Task; import backend.challenge.modules.task.repositories.ITaskRepository; import backend.challenge.modules.task.repositories.TaskRepository; import kikaha.core.test.KikahaRunner; +import kikaha.urouting.api.DefaultResponse; +import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.Date; + +import static org.mockito.Mockito.when; @RunWith( KikahaRunner.class ) public class RetrieveTaskByIdServiceTest { private IRetrieveTaskByIdService retrieveTaskByIdService; + @Mock + final ITaskRepository taskRepository = new TaskRepository(); + private final Task task = new Task(); + private final Long TASK_ID = 6679377763735439322L; + + @Before + public void Iinit() { + MockitoAnnotations.initMocks(this); + retrieveTaskByIdService = new RetriveTaskByIdService(taskRepository); + task.setId(TASK_ID); + task.setTitle("Compras"); + task.setDescription("Comprar presente para minha esposa"); + task.setProgress(0); + task.setStatus(TaskStatus.PROGRESS); + task.setCreatedAt(new Date()); + } @Test - public void shouldBeAbleToListTheTaskById() { + public void shouldBeAbleToListTheTaskById(){ /* TODO: Para que esse teste passe, sua aplicação deve permitir que seja retornado uma tarefa com o mesmo id informado. */ + when(taskRepository.index(TASK_ID)).thenReturn(task); + final DefaultResponse defaultResponse = retrieveTaskByIdService.execute(TASK_ID); + Task retrivedTask = (Task) defaultResponse.entity(); + Assert.assertEquals(task.getId(), retrivedTask.getId()); } } diff --git a/tests/backend/challenge/modules/task/services/UpdateTaskProgressServiceTest.java b/tests/backend/challenge/modules/task/services/UpdateTaskProgressServiceTest.java index e6b0bf6..8efccaa 100644 --- a/tests/backend/challenge/modules/task/services/UpdateTaskProgressServiceTest.java +++ b/tests/backend/challenge/modules/task/services/UpdateTaskProgressServiceTest.java @@ -1,19 +1,74 @@ package backend.challenge.modules.task.services; +import backend.challenge.modules.task.dtos.TaskProgressDtoFactory; +import backend.challenge.modules.task.enums.TaskStatus; +import backend.challenge.modules.task.models.Task; +import backend.challenge.modules.task.repositories.ITaskRepository; +import backend.challenge.modules.task.repositories.TaskRepository; import kikaha.core.test.KikahaRunner; +import kikaha.urouting.api.DefaultResponse; +import org.junit.Assert; +import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.Date; + +import static org.mockito.Matchers.anyLong; +import static org.mockito.Matchers.anyObject; +import static org.mockito.Mockito.when; @RunWith( KikahaRunner.class ) public class UpdateTaskProgressServiceTest { + private IUpdateTaskProgressService updateTaskProgressService; + + @Mock + private ITaskRepository taskRepository = new TaskRepository(); + + private final Task retrivedTask = new Task(); + private final Task updatedTask = new Task(); + private final Long TASK_ID = 8567032865818388301L; + private final int OLD_TASK_PROGRESS = 10; + private final TaskStatus TASK_STATUS = TaskStatus.PROGRESS; + private final Date CREATE_AT = new Date(2024, 4, 28); + private final String TASk_TITLE = "Projeto"; + private final String TASk_DESCRIPTION = "Implementar chat com llama3"; + + @Before + public void init() { + MockitoAnnotations.initMocks(this); + updateTaskProgressService = new UpdateTaskProgressService(taskRepository); + retrivedTask.setId(TASK_ID); + retrivedTask.setTitle(TASk_TITLE); + retrivedTask.setDescription(TASk_DESCRIPTION); + retrivedTask.setProgress(OLD_TASK_PROGRESS); + retrivedTask.setStatus(TASK_STATUS); + retrivedTask.setCreatedAt(CREATE_AT); + + updatedTask.setId(TASK_ID); + updatedTask.setTitle(TASk_TITLE); + updatedTask.setDescription(TASk_DESCRIPTION); + updatedTask.setProgress(50); + updatedTask.setStatus(TASK_STATUS); + updatedTask.setCreatedAt(CREATE_AT); + } + @Test public void shouldBeAbleToUpdateTaskProgress() { /* TODO: Para que esse teste passe, sua aplicação deve permitir que sejam alterados apenas o campo `progress`. */ + final int expectedProgress = 50; + when(taskRepository.index(anyLong())).thenReturn(retrivedTask); + when(taskRepository.updateProgress(anyObject())).thenReturn(updatedTask); + DefaultResponse defaultResponse = updateTaskProgressService.execute(new TaskProgressDtoFactory().build(TASK_ID, expectedProgress)); + Task task = (Task) defaultResponse.entity(); + Assert.assertNotEquals(task.getProgress(), OLD_TASK_PROGRESS); } @Test @@ -22,6 +77,78 @@ public void shouldBeAbleToUpdateOnlyTaskStatusWhenProgressEqualsOneHundred() { TODO: Para que esse teste passe, sua aplicação deve permitir que sejam alterado apenas o campo `status`, quando o progresso for igual a 100. */ + final Task completedTask = new Task(); + completedTask.setId(TASK_ID); + completedTask.setTitle(TASk_TITLE); + completedTask.setDescription(TASk_DESCRIPTION); + completedTask.setProgress(100); + completedTask.setStatus(TaskStatus.COMPLETE); + completedTask.setCreatedAt(CREATE_AT); + + final int progress = 100; + when(taskRepository.index(anyLong())).thenReturn(retrivedTask); + when(taskRepository.updateProgress(anyObject())).thenReturn(completedTask); + DefaultResponse defaultResponse = updateTaskProgressService.execute(new TaskProgressDtoFactory().build(TASK_ID, progress)); + Task task = (Task) defaultResponse.entity(); + Assert.assertEquals(task.getStatus(), TaskStatus.COMPLETE); + } + + @Test + public void shouldNotBeAbleToUpdateTaskProgressWhenProgressLessThanOneHundred() { + /* + TODO: Não deve ser capaz de atualizar o progresso da tarefa quando o progresso for inferior a cem. + */ + + final int progress = 99; + when(taskRepository.index(anyLong())).thenReturn(retrivedTask); + when(taskRepository.updateProgress(anyObject())).thenReturn(updatedTask); + DefaultResponse defaultResponse = updateTaskProgressService.execute(new TaskProgressDtoFactory().build(TASK_ID, progress)); + Task task = (Task) defaultResponse.entity(); + Assert.assertNotEquals(task.getStatus(), TaskStatus.COMPLETE); + } + + @Test + public void shouldNotBeAbleToUpdateTaskProgressWhenProgressLessThanZero() { + /* + TODO: Para que esse teste passe, você não deve permitir + que sua rota de update de progresso de tarefa altere o progresso para menor que 0. + */ + final Task updatedTaskWithZeroProgress = new Task(); + updatedTaskWithZeroProgress.setId(TASK_ID); + updatedTaskWithZeroProgress.setTitle(TASk_TITLE); + updatedTaskWithZeroProgress.setDescription(TASk_DESCRIPTION); + updatedTaskWithZeroProgress.setProgress(0); + updatedTaskWithZeroProgress.setStatus(TASK_STATUS); + updatedTaskWithZeroProgress.setCreatedAt(CREATE_AT); + + when(taskRepository.index(anyLong())).thenReturn(retrivedTask); + when(taskRepository.updateProgress(anyObject())).thenReturn(updatedTaskWithZeroProgress); + final int progress = -3; + DefaultResponse defaultResponse = updateTaskProgressService.execute(new TaskProgressDtoFactory().build(TASK_ID, progress)); + Task task = (Task) defaultResponse.entity(); + Assert.assertEquals(task.getProgress(), 0); + } + + @Test + public void shouldNotBeAbleToUpdateTaskProgressWhenProgressGreaterThanOneHundred() { + /* + TODO: Para que esse teste passe, você não deve permitir + que sua rota de update de progresso de tarefa altere o progresso para maior que 100. + */ + final Task updatedTaskWithZeroProgress = new Task(); + updatedTaskWithZeroProgress.setId(TASK_ID); + updatedTaskWithZeroProgress.setTitle(TASk_TITLE); + updatedTaskWithZeroProgress.setDescription(TASk_DESCRIPTION); + updatedTaskWithZeroProgress.setProgress(100); + updatedTaskWithZeroProgress.setStatus(TASK_STATUS); + updatedTaskWithZeroProgress.setCreatedAt(CREATE_AT); + + when(taskRepository.index(anyLong())).thenReturn(retrivedTask); + when(taskRepository.updateProgress(anyObject())).thenReturn(updatedTaskWithZeroProgress); + final int progress = 200; + DefaultResponse defaultResponse = updateTaskProgressService.execute(new TaskProgressDtoFactory().build(TASK_ID, progress)); + Task task = (Task) defaultResponse.entity(); + Assert.assertEquals(task.getProgress(), 100); } } diff --git a/tests/backend/challenge/modules/task/services/UpdateTaskServiceTest.java b/tests/backend/challenge/modules/task/services/UpdateTaskServiceTest.java index 53a4082..18ebe0b 100644 --- a/tests/backend/challenge/modules/task/services/UpdateTaskServiceTest.java +++ b/tests/backend/challenge/modules/task/services/UpdateTaskServiceTest.java @@ -1,24 +1,81 @@ package backend.challenge.modules.task.services; +import backend.challenge.modules.task.enums.TaskStatus; +import backend.challenge.modules.task.models.Task; import backend.challenge.modules.task.repositories.ITaskRepository; import backend.challenge.modules.task.repositories.TaskRepository; + import kikaha.core.test.KikahaRunner; +import kikaha.urouting.api.DefaultResponse; +import org.junit.Assert; import org.junit.Before; -import org.junit.Ignore; + import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.Date; + +import static org.mockito.Matchers.anyLong; +import static org.mockito.Matchers.anyObject; +import static org.mockito.Mockito.when; @RunWith( KikahaRunner.class ) public class UpdateTaskServiceTest { private IUpdateTaskService updateTaskService; + @Mock + private ITaskRepository taskRepository = new TaskRepository(); + private final Task retrivedTask = new Task(); + private final Task taskChanges = new Task(); + private final Task updatedTask = new Task(); + private final Long TASK_ID = 8567032865818388301L; + private final int TASK_PROGRESS = 50; + private final TaskStatus TASK_STATUS = TaskStatus.PROGRESS; + private final Date CREATE_AT = new Date(2024, 4, 28); + private final String OLD_TASk_TITLE = "Trabalho"; + private final String OLD_TASk_DESCRIPTION = "Capinar meu terreno"; + + @Before + public void init() { + MockitoAnnotations.initMocks(this); + updateTaskService = new UpdateTaskService(taskRepository); + + retrivedTask.setId(TASK_ID); + retrivedTask.setTitle(OLD_TASk_TITLE); + retrivedTask.setDescription(OLD_TASk_DESCRIPTION); + retrivedTask.setProgress(TASK_PROGRESS); + retrivedTask.setStatus(TASK_STATUS); + retrivedTask.setCreatedAt(CREATE_AT); + + taskChanges.setId(6714351139364770828L); + taskChanges.setTitle("Compras"); + taskChanges.setDescription("Comprar presente pra minha esposa"); + taskChanges.setProgress(0); + taskChanges.setStatus(TaskStatus.PROGRESS); + taskChanges.setCreatedAt(CREATE_AT); + + updatedTask.setId(TASK_ID); + updatedTask.setTitle("Compras"); + updatedTask.setDescription("Comprar presente pra minha esposa"); + updatedTask.setProgress(50); + updatedTask.setStatus(TaskStatus.PROGRESS); + updatedTask.setCreatedAt(CREATE_AT); + } + @Test public void shouldBeAbleToUpdateTask() { /* TODO: Para que esse teste passe, sua aplicação deve permitir que sejam alterados apenas os campos `title` e `observation`. */ + when(taskRepository.index(anyLong())).thenReturn(retrivedTask); + when(taskRepository.update(anyObject())).thenReturn(updatedTask); + final DefaultResponse defaultResponse = updateTaskService.execute(TASK_ID, taskChanges); + Assert.assertNotEquals(retrivedTask.getTitle(), OLD_TASk_TITLE); + Assert.assertNotEquals(retrivedTask.getDescription(), OLD_TASk_DESCRIPTION); } @Test @@ -27,6 +84,9 @@ public void shouldNotBeAbleToUpdateATaskThatDoesNotExist() { TODO: Para que esse teste passe, você deve validar na sua rota de update se o id da tarefa enviada pela url existe ou não. Caso não exista, retornar um erro com status 400. */ + final DefaultResponse defaultResponse = updateTaskService.execute(5101162744757410452L, taskChanges); + DefaultResponse expectedResponse = DefaultResponse.notFound().statusCode(404); + Assert.assertEquals(expectedResponse.statusCode(), defaultResponse.statusCode()); } @Test @@ -38,6 +98,10 @@ public void shouldNotBeAbleToUpdateTaskStatusManually() { é a rota responsável por alterar o progresso da tarefa. */ + when(taskRepository.index(anyLong())).thenReturn(retrivedTask); + when(taskRepository.update(anyObject())).thenReturn(updatedTask); + final DefaultResponse defaultResponse = updateTaskService.execute(TASK_ID, taskChanges); + Assert.assertEquals(retrivedTask.getStatus(), TASK_STATUS); }