diff --git a/lib/taskana-cdi-example/src/main/java/pro/taskana/ExampleBootstrap.java b/lib/taskana-cdi-example/src/main/java/pro/taskana/ExampleBootstrap.java index 31a288f6d..00dea72ab 100644 --- a/lib/taskana-cdi-example/src/main/java/pro/taskana/ExampleBootstrap.java +++ b/lib/taskana-cdi-example/src/main/java/pro/taskana/ExampleBootstrap.java @@ -8,6 +8,7 @@ import javax.enterprise.event.Observes; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.TaskNotFoundException; +import pro.taskana.exceptions.WorkbasketNotFoundException; import pro.taskana.model.Task; @ApplicationScoped @@ -17,7 +18,7 @@ public class ExampleBootstrap { private TaskanaEjb taskanaEjb; @PostConstruct - public void init(@Observes @Initialized(ApplicationScoped.class) Object init) throws TaskNotFoundException, NotAuthorizedException { + public void init(@Observes @Initialized(ApplicationScoped.class) Object init) throws TaskNotFoundException, NotAuthorizedException, WorkbasketNotFoundException { System.out.println("---------------------------> Start App"); Task task = taskanaEjb.getTaskService().create(new Task()); System.out.println("---------------------------> Task started: " + task.getId()); diff --git a/lib/taskana-cdi/src/test/java/pro/taskana/TaskanaEjb.java b/lib/taskana-cdi/src/test/java/pro/taskana/TaskanaEjb.java index c89c70bbb..99fd0a9dd 100644 --- a/lib/taskana-cdi/src/test/java/pro/taskana/TaskanaEjb.java +++ b/lib/taskana-cdi/src/test/java/pro/taskana/TaskanaEjb.java @@ -4,6 +4,7 @@ import javax.ejb.Stateless; import javax.inject.Inject; import pro.taskana.exceptions.NotAuthorizedException; +import pro.taskana.exceptions.WorkbasketNotFoundException; import pro.taskana.model.Task; @Stateless @@ -16,7 +17,7 @@ public class TaskanaEjb { return taskService; } - public void triggerRollback() throws NotAuthorizedException { + public void triggerRollback() throws NotAuthorizedException, WorkbasketNotFoundException { Task t = taskService.create(new Task()); System.out.println("---------------->" + t.getId()); throw new RuntimeException(); diff --git a/lib/taskana-cdi/src/test/java/pro/taskana/TaskanaRestTest.java b/lib/taskana-cdi/src/test/java/pro/taskana/TaskanaRestTest.java index 842b9b7a0..3f2bc232d 100644 --- a/lib/taskana-cdi/src/test/java/pro/taskana/TaskanaRestTest.java +++ b/lib/taskana-cdi/src/test/java/pro/taskana/TaskanaRestTest.java @@ -12,6 +12,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.TaskNotFoundException; +import pro.taskana.exceptions.WorkbasketNotFoundException; import pro.taskana.model.Task; @Path("/test") @@ -23,14 +24,14 @@ public class TaskanaRestTest { private TaskanaEjb taskanaEjb; @GET - public Response startTask() throws NotAuthorizedException { + public Response startTask() throws NotAuthorizedException, WorkbasketNotFoundException { Task result = taskanaEjb.getTaskService().create(new Task()); logger.info(result.getId() + ":" + result.getOwner()); return Response.status(200).entity(result.getId()).build(); } @POST - public Response rollbackTask() throws NotAuthorizedException { + public Response rollbackTask() throws NotAuthorizedException, WorkbasketNotFoundException { taskanaEjb.triggerRollback(); return Response.status(204).build(); } diff --git a/lib/taskana-core/src/main/java/pro/taskana/TaskService.java b/lib/taskana-core/src/main/java/pro/taskana/TaskService.java index 469b583d4..356f5fad8 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/TaskService.java +++ b/lib/taskana-core/src/main/java/pro/taskana/TaskService.java @@ -21,17 +21,19 @@ public interface TaskService { * task id * @param userName * user who claims the task + * @return modified claimed Task * @throws TaskNotFoundException */ - void claim(String id, String userName) throws TaskNotFoundException; + Task claim(String id, String userName) throws TaskNotFoundException; /** * Set task to completed. * @param taskId * the task id + * @return changed Task after update. * @throws TaskNotFoundException */ - void complete(String taskId) throws TaskNotFoundException; + Task complete(String taskId) throws TaskNotFoundException; /** * Create a task by a task object. @@ -39,7 +41,7 @@ public interface TaskService { * @return the created task * @throws NotAuthorizedException */ - Task create(Task task) throws NotAuthorizedException; + Task create(Task task) throws NotAuthorizedException, WorkbasketNotFoundException; /** * Get the details of a task. diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/TaskServiceImpl.java b/lib/taskana-core/src/main/java/pro/taskana/impl/TaskServiceImpl.java index ce31aaf49..c27396268 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/TaskServiceImpl.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/TaskServiceImpl.java @@ -51,10 +51,11 @@ public class TaskServiceImpl implements TaskService { } @Override - public void claim(String id, String userName) throws TaskNotFoundException { + public Task claim(String id, String userName) throws TaskNotFoundException { + Task task = null; try { taskanaEngineImpl.openConnection(); - Task task = taskMapper.findById(id); + task = taskMapper.findById(id); if (task != null) { Timestamp now = new Timestamp(System.currentTimeMillis()); task.setOwner(userName); @@ -69,13 +70,15 @@ public class TaskServiceImpl implements TaskService { } finally { taskanaEngineImpl.returnConnection(); } + return task; } @Override - public void complete(String id) throws TaskNotFoundException { + public Task complete(String id) throws TaskNotFoundException { + Task task = null; try { taskanaEngineImpl.openConnection(); - Task task = taskMapper.findById(id); + task = taskMapper.findById(id); if (task != null) { Timestamp now = new Timestamp(System.currentTimeMillis()); task.setCompleted(now); @@ -89,10 +92,11 @@ public class TaskServiceImpl implements TaskService { } finally { taskanaEngineImpl.returnConnection(); } + return task; } @Override - public Task create(Task task) throws NotAuthorizedException { + public Task create(Task task) throws NotAuthorizedException, WorkbasketNotFoundException { try { taskanaEngineImpl.openConnection(); taskanaEngine.getWorkbasketService().checkAuthorization(task.getWorkbasketId(), WorkbasketAuthorization.APPEND); diff --git a/lib/taskana-core/src/test/java/pro/taskana/impl/TaskServiceImplTest.java b/lib/taskana-core/src/test/java/pro/taskana/impl/TaskServiceImplTest.java index c042f7374..6e3a4c95c 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/impl/TaskServiceImplTest.java +++ b/lib/taskana-core/src/test/java/pro/taskana/impl/TaskServiceImplTest.java @@ -1,11 +1,24 @@ package pro.taskana.impl; +import static org.hamcrest.core.IsEqual.equalTo; +import static org.hamcrest.core.IsNot.not; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertThat; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import java.sql.Date; import java.sql.Timestamp; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; -import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; @@ -20,10 +33,13 @@ import pro.taskana.configuration.TaskanaEngineConfiguration; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.TaskNotFoundException; import pro.taskana.exceptions.WorkbasketNotFoundException; +import pro.taskana.model.DueWorkbasketCounter; import pro.taskana.model.ObjectReference; import pro.taskana.model.Task; import pro.taskana.model.TaskState; +import pro.taskana.model.TaskStateCounter; import pro.taskana.model.Workbasket; +import pro.taskana.model.WorkbasketAuthorization; import pro.taskana.model.mappings.ObjectReferenceMapper; import pro.taskana.model.mappings.TaskMapper; @@ -35,29 +51,35 @@ import pro.taskana.model.mappings.TaskMapper; public class TaskServiceImplTest { private static final int SLEEP_TIME = 100; - @Mock - TaskanaEngineConfiguration taskanaEngineConfiguration; @InjectMocks - TaskServiceImpl taskServiceImpl; + private TaskServiceImpl cut; + @Mock - TaskanaEngineImpl taskanaEngine; + private TaskanaEngineConfiguration taskanaEngineConfigurationMock; + @Mock - TaskanaEngineImpl taskanaEngineImpl; + private TaskanaEngineImpl taskanaEngineMock; + @Mock - TaskMapper taskMapper; + private TaskanaEngineImpl taskanaEngineImpl; + @Mock - ObjectReferenceMapper objectReferenceMapper; + private TaskMapper taskMapperMock; + @Mock - WorkbasketService workbasketService; + private ObjectReferenceMapper objectReferenceMapperMock; + + @Mock + private WorkbasketService workbasketServiceMock; @Before public void setup() { MockitoAnnotations.initMocks(this); - Mockito.when(taskanaEngine.getWorkbasketService()).thenReturn(workbasketService); + doReturn(workbasketServiceMock).when(taskanaEngineMock).getWorkbasketService(); try { - Mockito.doNothing().when(workbasketService).checkAuthorization(any(), any()); + Mockito.doNothing().when(workbasketServiceMock).checkAuthorization(any(), any()); } catch (NotAuthorizedException e) { e.printStackTrace(); } @@ -66,144 +88,482 @@ public class TaskServiceImplTest { } @Test - public void testCreateSimpleTask() throws NotAuthorizedException { - Mockito.doNothing().when(taskMapper).insert(any()); - Task task = new Task(); - task.setName("Unit Test Task"); - task.setWorkbasketId("1"); - task.setBusinessProcessId("BPI1"); - task.setParentBusinessProcessId("PBPI1"); - task = taskServiceImpl.create(task); - Assert.assertNull(task.getOwner()); - Assert.assertNotNull(task.getCreated()); - Assert.assertNotNull(task.getModified()); - Assert.assertNull(task.getCompleted()); - Assert.assertEquals(task.getWorkbasketId(), "1"); - Assert.assertEquals(task.getBusinessProcessId(), "BPI1"); - Assert.assertEquals(task.getParentBusinessProcessId(), "PBPI1"); - Assert.assertEquals(task.getState(), TaskState.READY); + public void testCreateSimpleTask() throws NotAuthorizedException, WorkbasketNotFoundException { + Mockito.doNothing().when(taskMapperMock).insert(any()); + Task expectedTask = createUnitTestTask("1", "DUMMYTASK", "1"); + + Task actualTask = cut.create(expectedTask); + + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskanaEngineMock, times(1)).getWorkbasketService(); + verify(workbasketServiceMock, times(1)).checkAuthorization(any(), any()); + verify(taskMapperMock, times(1)).insert(expectedTask); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + assertNull(actualTask.getOwner()); + assertNotNull(actualTask.getCreated()); + assertNotNull(actualTask.getModified()); + assertNull(actualTask.getCompleted()); + assertThat(actualTask.getWorkbasketId(), equalTo(expectedTask.getWorkbasketId())); + assertThat(actualTask.getName(), equalTo(expectedTask.getName())); + assertThat(actualTask.getState(), equalTo(TaskState.READY)); } @Test - public void testClaim() throws Exception { - Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); + public void testCreateSimpleTaskWithObjectReference() throws NotAuthorizedException, WorkbasketNotFoundException { + ObjectReference expectedObjectReference = new ObjectReference(); + expectedObjectReference.setId("1"); + expectedObjectReference.setType("DUMMY"); + Task expectedTask = createUnitTestTask("1", "DUMMYTASK", "1"); + expectedTask.setPrimaryObjRef(new ObjectReference()); + + Mockito.doNothing().when(taskMapperMock).insert(any()); + Mockito.doReturn(expectedObjectReference).when(objectReferenceMapperMock).findByObjectReference(any()); + + Task actualTask = cut.create(expectedTask); + + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskanaEngineMock, times(1)).getWorkbasketService(); + verify(workbasketServiceMock, times(1)).checkAuthorization(any(), any()); + verify(objectReferenceMapperMock, times(1)).findByObjectReference(any()); + verify(taskMapperMock, times(1)).insert(expectedTask); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + + assertNull(actualTask.getOwner()); + assertNotNull(actualTask.getCreated()); + assertNotNull(actualTask.getModified()); + assertNull(actualTask.getCompleted()); + assertThat(actualTask.getWorkbasketId(), equalTo(expectedTask.getWorkbasketId())); + assertThat(actualTask.getName(), equalTo(expectedTask.getName())); + assertThat(actualTask.getState(), equalTo(TaskState.READY)); + assertThat(actualTask.getPrimaryObjRef(), equalTo(expectedObjectReference)); + } + + @Test + public void testCreateSimpleTaskWithObjectReferenceIsNull() throws NotAuthorizedException, WorkbasketNotFoundException { + ObjectReference expectedObjectReference = new ObjectReference(); + expectedObjectReference.setId("1"); + expectedObjectReference.setType("DUMMY"); + + Task expectedTask = createUnitTestTask("1", "DUMMYTASK", "1"); + expectedTask.setPrimaryObjRef(expectedObjectReference); + + Mockito.doNothing().when(taskMapperMock).insert(any()); + Mockito.doNothing().when(objectReferenceMapperMock).insert(any()); + Mockito.doReturn(null).when(objectReferenceMapperMock).findByObjectReference(any()); + + Task actualTask = cut.create(expectedTask); + expectedTask.getPrimaryObjRef().setId(actualTask.getPrimaryObjRef().getId()); // get only new ID + + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskanaEngineMock, times(1)).getWorkbasketService(); + verify(workbasketServiceMock, times(1)).checkAuthorization(any(), any()); + verify(objectReferenceMapperMock, times(1)).findByObjectReference(any()); + verify(objectReferenceMapperMock, times(1)).insert(any()); + verify(taskMapperMock, times(1)).insert(expectedTask); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + + assertNull(actualTask.getOwner()); + assertNotNull(actualTask.getCreated()); + assertNotNull(actualTask.getModified()); + assertNull(actualTask.getCompleted()); + assertThat(actualTask.getWorkbasketId(), equalTo(expectedTask.getWorkbasketId())); + assertThat(actualTask.getName(), equalTo(expectedTask.getName())); + assertThat(actualTask.getState(), equalTo(TaskState.READY)); + assertThat(actualTask.getPrimaryObjRef(), equalTo(expectedObjectReference)); + } + + @Test(expected = NotAuthorizedException.class) + public void testCreateThrowingAuthorizedOnWorkbasket() throws NotAuthorizedException, WorkbasketNotFoundException { + try { + Mockito.doThrow(NotAuthorizedException.class).when(workbasketServiceMock).checkAuthorization(any(), any()); + Task task = new Task(); + task.setWorkbasketId("1"); + + cut.create(task); + } catch (Exception e) { + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskanaEngineMock, times(1)).getWorkbasketService(); + verify(workbasketServiceMock, times(1)).checkAuthorization(any(), any()); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + throw e; + } + } + + @Test(expected = WorkbasketNotFoundException.class) + public void testCreateThrowsWorkbasketNotFoundException() throws NotAuthorizedException, WorkbasketNotFoundException { + try { + Mockito.doThrow(WorkbasketNotFoundException.class).when(workbasketServiceMock).checkAuthorization(any(), any()); + Task task = new Task(); + task.setWorkbasketId("1"); + + cut.create(task); + } catch (Exception e) { + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskanaEngineMock, times(1)).getWorkbasketService(); + verify(workbasketServiceMock, times(1)).checkAuthorization(any(), any()); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + throw e; + } + } + + @Test + public void testClaimSuccessfulToOwner() throws Exception { + Task expectedTask = createUnitTestTask("1", "Unit Test Task 1", "1"); + Mockito.doReturn(expectedTask).when(taskMapperMock).findById(expectedTask.getId()); Thread.sleep(SLEEP_TIME); // to have different timestamps - taskServiceImpl.claim(task.getId(), "John Does"); - task = taskServiceImpl.getTaskById(task.getId()); - Assert.assertEquals(task.getState(), TaskState.CLAIMED); - Assert.assertNotEquals(task.getCreated(), task.getModified()); - Assert.assertNotNull(task.getClaimed()); - Assert.assertEquals(task.getOwner(), "John Does"); + String expectedOwner = "John Does"; + + Task acturalTask = cut.claim(expectedTask.getId(), expectedOwner); + + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskMapperMock, times(1)).findById(expectedTask.getId()); + verify(taskMapperMock, times(1)).update(any()); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + + assertThat(acturalTask.getState(), equalTo(TaskState.CLAIMED)); + assertThat(acturalTask.getCreated(), not(equalTo(expectedTask.getModified()))); + assertThat(acturalTask.getClaimed(), not(equalTo(null))); + assertThat(acturalTask.getOwner(), equalTo(expectedOwner)); } @Test(expected = TaskNotFoundException.class) - public void testClaimFailsWithNonExistingTaskId() throws TaskNotFoundException { - taskServiceImpl.claim("test", "John Doe"); + public void testClaimThrowinTaskNotFoundException() throws TaskNotFoundException { + try { + Task expectedTask = null; + Mockito.doReturn(expectedTask).when(taskMapperMock).findById(any()); + + cut.claim("1", "OWNER"); + } catch (Exception e) { + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskMapperMock, times(1)).findById(any()); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + throw e; + } } @Test - public void testComplete() throws Exception { - Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); - + public void testCompleteTask() throws TaskNotFoundException, InterruptedException { + Task expectedTask = createUnitTestTask("1", "Unit Test Task 1", "1"); Thread.sleep(SLEEP_TIME); // to have different timestamps - taskServiceImpl.complete(task.getId()); - task = taskServiceImpl.getTaskById(task.getId()); - Assert.assertEquals(task.getState(), TaskState.COMPLETED); - Assert.assertNotEquals(task.getCreated(), task.getModified()); - Assert.assertNotNull(task.getCompleted()); + Mockito.doReturn(expectedTask).when(taskMapperMock).findById(expectedTask.getId()); + + Task actualTask = cut.complete(expectedTask.getId()); + + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskMapperMock, times(1)).findById(expectedTask.getId()); + verify(taskMapperMock, times(1)).update(any()); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + + assertThat(actualTask.getState(), equalTo(TaskState.COMPLETED)); + assertThat(actualTask.getCreated(), not(equalTo(expectedTask.getModified()))); + assertThat(actualTask.getCompleted(), not(equalTo(null))); } @Test(expected = TaskNotFoundException.class) public void testCompleteFailsWithNonExistingTaskId() throws TaskNotFoundException { - taskServiceImpl.complete("test"); + String invalidTaskId = ""; + try { + cut.complete(invalidTaskId); + } catch (Exception e) { + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskMapperMock, times(1)).findById(invalidTaskId); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + throw e; + } } @Test - public void testTransferTaskZuDestinationWorkbasket() + public void testTransferTaskToDestinationWorkbasketWithoutSecurity() throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { - Workbasket workbasket2 = createWorkbasket2(); + TaskServiceImpl cutSpy = Mockito.spy(cut); + Workbasket destinationWorkbasket = createWorkbasket("2"); + Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); + final int workServiceMockCalls = 3; + task.setRead(true); + doReturn(destinationWorkbasket).when(workbasketServiceMock).getWorkbasket(destinationWorkbasket.getId()); + doReturn(taskanaEngineConfigurationMock).when(taskanaEngineMock).getConfiguration(); + doReturn(false).when(taskanaEngineConfigurationMock).isSecurityEnabled(); + doReturn(task).when(cutSpy).getTaskById(task.getId()); + doNothing().when(taskMapperMock).update(any()); + doNothing().when(workbasketServiceMock).checkAuthorization(destinationWorkbasket.getId(), WorkbasketAuthorization.APPEND); + doNothing().when(workbasketServiceMock).checkAuthorization(task.getId(), WorkbasketAuthorization.TRANSFER); - Mockito.when(taskanaEngine.getWorkbasketService().getWorkbasket("2")).thenReturn(workbasket2); + Task actualTask = cutSpy.transfer(task.getId(), destinationWorkbasket.getId()); + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskanaEngineMock, times(workServiceMockCalls)).getWorkbasketService(); + verify(workbasketServiceMock, times(1)).checkAuthorization(destinationWorkbasket.getId(), WorkbasketAuthorization.APPEND); + verify(workbasketServiceMock, times(1)).checkAuthorization(task.getId(), WorkbasketAuthorization.TRANSFER); + verify(taskanaEngineMock, times(1)).getConfiguration(); + verify(taskanaEngineConfigurationMock, times(1)).isSecurityEnabled(); + verify(workbasketServiceMock, times(1)).getWorkbasket(destinationWorkbasket.getId()); + verify(taskMapperMock, times(1)).update(any()); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + + assertThat(actualTask.isRead(), equalTo(false)); + assertThat(actualTask.isTransferred(), equalTo(true)); + assertThat(actualTask.getWorkbasketId(), equalTo(destinationWorkbasket.getId())); + } + + @Test + public void testTransferTaskToDestinationWorkbasketUsingSecurityTrue() + throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { + TaskServiceImpl cutSpy = Mockito.spy(cut); + Workbasket destinationWorkbasket = createWorkbasket("2"); Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); task.setRead(true); + doReturn(taskanaEngineConfigurationMock).when(taskanaEngineMock).getConfiguration(); + doReturn(true).when(taskanaEngineConfigurationMock).isSecurityEnabled(); + doReturn(task).when(cutSpy).getTaskById(task.getId()); + doNothing().when(taskMapperMock).update(any()); + doNothing().when(workbasketServiceMock).checkAuthorization(destinationWorkbasket.getId(), WorkbasketAuthorization.APPEND); + doNothing().when(workbasketServiceMock).checkAuthorization(task.getId(), WorkbasketAuthorization.TRANSFER); - // taskanaEngine.getConfiguration().isSecurityEnabled()) - Mockito.when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration); - Mockito.when(taskanaEngineConfiguration.isSecurityEnabled()).thenReturn(false); + Task actualTask = cutSpy.transfer(task.getId(), destinationWorkbasket.getId()); - Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "1"); - taskServiceImpl.transfer(task.getId(), "2"); - Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "2"); + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskanaEngineMock, times(2)).getWorkbasketService(); + verify(workbasketServiceMock, times(1)).checkAuthorization(destinationWorkbasket.getId(), WorkbasketAuthorization.APPEND); + verify(workbasketServiceMock, times(1)).checkAuthorization(task.getId(), WorkbasketAuthorization.TRANSFER); + verify(taskanaEngineMock, times(1)).getConfiguration(); + verify(taskanaEngineConfigurationMock, times(1)).isSecurityEnabled(); + verify(taskMapperMock, times(1)).update(any()); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); - Assert.assertTrue(task.isTransferred()); - Assert.assertFalse(task.isRead()); + assertThat(actualTask.isRead(), equalTo(false)); + assertThat(actualTask.isTransferred(), equalTo(true)); + assertThat(actualTask.getWorkbasketId(), equalTo(destinationWorkbasket.getId())); } @Test(expected = WorkbasketNotFoundException.class) - public void testTransferFailsIfDestinationWorkbasketDoesNotExist_withSecurityDisabled() + public void testTransferDestinationWorkbasketDoesNotExist() throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { - Mockito.doThrow(WorkbasketNotFoundException.class).when(workbasketService) - .checkAuthorization(eq("invalidWorkbasketId"), any()); + String destinationWorkbasketId = "2"; Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); + TaskServiceImpl cutSpy = Mockito.spy(cut); + doThrow(WorkbasketNotFoundException.class).when(workbasketServiceMock).checkAuthorization(destinationWorkbasketId, WorkbasketAuthorization.APPEND); + doReturn(task).when(cutSpy).getTaskById(task.getId()); - Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "1"); - taskServiceImpl.transfer(task.getId(), "invalidWorkbasketId"); + try { + cutSpy.transfer(task.getId(), destinationWorkbasketId); + } catch (Exception e) { + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskanaEngineMock, times(1)).getWorkbasketService(); + verify(workbasketServiceMock, times(1)).checkAuthorization(destinationWorkbasketId, WorkbasketAuthorization.APPEND); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + throw e; + } } - @Test(expected = WorkbasketNotFoundException.class) - public void testTransferFailsIfDestinationWorkbasketDoesNotExist_withSecurityEnabled() + @Test(expected = TaskNotFoundException.class) + public void testTransferTaskDoesNotExist() throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { - Mockito.doThrow(WorkbasketNotFoundException.class).when(workbasketService).checkAuthorization(eq("invalidWorkbasketId"), any()); Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); + TaskServiceImpl cutSpy = Mockito.spy(cut); + doThrow(TaskNotFoundException.class).when(cutSpy).getTaskById(task.getId()); - Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "1"); - taskServiceImpl.transfer(task.getId(), "invalidWorkbasketId"); + try { + cutSpy.transfer(task.getId(), "2"); + } catch (Exception e) { + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + throw e; + } + } + + @Test(expected = NotAuthorizedException.class) + public void testTransferNotAuthorizationOnWorkbasketAppend() + throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { + String destinationWorkbasketId = "2"; + Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); + TaskServiceImpl cutSpy = Mockito.spy(cut); + doReturn(task).when(cutSpy).getTaskById(task.getId()); + doThrow(NotAuthorizedException.class).when(workbasketServiceMock).checkAuthorization(destinationWorkbasketId, WorkbasketAuthorization.APPEND); + + try { + cutSpy.transfer(task.getId(), destinationWorkbasketId); + } catch (Exception e) { + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskanaEngineMock, times(1)).getWorkbasketService(); + verify(workbasketServiceMock, times(1)).checkAuthorization(destinationWorkbasketId, WorkbasketAuthorization.APPEND); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + throw e; + } + } + + @Test(expected = NotAuthorizedException.class) + public void testTransferNotAuthorizationOnWorkbasketTransfer() + throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { + String destinationWorkbasketId = "2"; + Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); + TaskServiceImpl cutSpy = Mockito.spy(cut); + doReturn(task).when(cutSpy).getTaskById(task.getId()); + doNothing().when(workbasketServiceMock).checkAuthorization(destinationWorkbasketId, WorkbasketAuthorization.APPEND); + doThrow(NotAuthorizedException.class).when(workbasketServiceMock).checkAuthorization(task.getWorkbasketId(), WorkbasketAuthorization.TRANSFER); + + try { + cutSpy.transfer(task.getId(), destinationWorkbasketId); + } catch (Exception e) { + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskanaEngineMock, times(2)).getWorkbasketService(); + verify(workbasketServiceMock, times(1)).checkAuthorization(destinationWorkbasketId, WorkbasketAuthorization.APPEND); + verify(workbasketServiceMock, times(1)).checkAuthorization(task.getId(), WorkbasketAuthorization.TRANSFER); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + throw e; + } } @Test - public void should_setTheReadFlag_when_taskIsRead() throws TaskNotFoundException { - createUnitTestTask("1", "Unit Test Task 1", "1"); + public void testGetTaskCountForState() { + List taskStates = Arrays.asList(TaskState.CLAIMED, TaskState.COMPLETED); + List expectedResult = new ArrayList<>(); + doReturn(expectedResult).when(taskMapperMock).getTaskCountForState(taskStates); - Task readTask = taskServiceImpl.setTaskRead("1", true); - Assert.assertTrue(readTask.isRead()); + List actualResult = cut.getTaskCountForState(taskStates); + + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskMapperMock, times(1)).getTaskCountForState(taskStates); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + assertThat(actualResult, equalTo(expectedResult)); } @Test - public void should_InsertObjectReference_when_TaskIsCreated() throws NotAuthorizedException { - Mockito.when(objectReferenceMapper.findByObjectReference(any())).thenReturn(null); + public void testGetTaskCountForWorkbasketByDaysInPastAndState() { + List taskStates = Arrays.asList(TaskState.CLAIMED, TaskState.COMPLETED); + final long daysInPast = 10L; + final long expectedResult = 5L; + String workbasketId = "1"; + doReturn(expectedResult).when(taskMapperMock).getTaskCountForWorkbasketByDaysInPastAndState(any(), any(), any()); - Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); - ObjectReference primaryObjRef = new ObjectReference(); - primaryObjRef.setSystem("Sol"); - task.setPrimaryObjRef(primaryObjRef); - Task createdTask = taskServiceImpl.create(task); + long actualResult = cut.getTaskCountForWorkbasketByDaysInPastAndState(workbasketId, daysInPast, taskStates); - Assert.assertNotNull(createdTask.getPrimaryObjRef()); - Assert.assertNotNull(createdTask.getPrimaryObjRef().getId()); - Assert.assertEquals("Sol", createdTask.getPrimaryObjRef().getSystem()); + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskMapperMock, times(1)).getTaskCountForWorkbasketByDaysInPastAndState(any(), any(), any()); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + assertThat(actualResult, equalTo(expectedResult)); } @Test - public void should_LinkObjectReference_when_TaskIsCreated() throws NotAuthorizedException { + public void testGetTaskCountByWorkbasketAndDaysInPastAndState() { + final long daysInPast = 10L; + List taskStates = Arrays.asList(TaskState.CLAIMED, TaskState.COMPLETED); + List expectedResult = new ArrayList<>(); + doReturn(expectedResult).when(taskMapperMock).getTaskCountByWorkbasketIdAndDaysInPastAndState(any(Date.class), any()); + + List actualResult = cut.getTaskCountByWorkbasketAndDaysInPastAndState(daysInPast, taskStates); + + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskMapperMock, times(1)).getTaskCountByWorkbasketIdAndDaysInPastAndState(any(Date.class), any()); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + assertThat(actualResult, equalTo(expectedResult)); + } + + @Test + public void testSetTaskReadWIthExistingTask() throws TaskNotFoundException { + TaskServiceImpl cutSpy = Mockito.spy(cut); Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); - ObjectReference primaryObjRef = new ObjectReference(); - primaryObjRef.setSystem("Sol"); - task.setPrimaryObjRef(primaryObjRef); + task.setModified(null); + doReturn(task).when(cutSpy).getTaskById(task.getId()); + doNothing().when(taskMapperMock).update(task); - ObjectReference returnPrimaryObjRef = new ObjectReference(); - returnPrimaryObjRef.setId("1"); - returnPrimaryObjRef.setSystem("Sol"); + Task actualTask = cutSpy.setTaskRead("1", true); - Mockito.when(objectReferenceMapper.findByObjectReference(any())).thenReturn(returnPrimaryObjRef); - Task createdTask = taskServiceImpl.create(task); + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskMapperMock, times(1)).update(task); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + assertThat(actualTask.getModified(), not(equalTo(null))); + assertThat(actualTask.isRead(), equalTo(true)); + } - Assert.assertNotNull(createdTask.getPrimaryObjRef()); - Assert.assertEquals("1", createdTask.getPrimaryObjRef().getId()); - Assert.assertEquals("Sol", createdTask.getPrimaryObjRef().getSystem()); + @Test(expected = TaskNotFoundException.class) + public void testSetTaskReadTaskNotBeFound() throws TaskNotFoundException { + TaskServiceImpl cutSpy = Mockito.spy(cut); + Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); + task.setModified(null); + doThrow(TaskNotFoundException.class).when(cutSpy).getTaskById(task.getId()); + + try { + cutSpy.setTaskRead("1", true); + } catch (Exception e) { + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + throw e; + } + } + + @Test + public void testGetTaskByIdWithExistingTask() throws TaskNotFoundException { + Task expectedTask = createUnitTestTask("1", "DUMMY-TASK", "1"); + doReturn(expectedTask).when(taskMapperMock).findById(expectedTask.getId()); + + Task actualTask = cut.getTaskById(expectedTask.getId()); + + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskMapperMock, times(1)).findById(expectedTask.getId()); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + assertThat(actualTask, equalTo(expectedTask)); + } + + @Test(expected = TaskNotFoundException.class) + public void testGetTaskByIdWhereTaskDoesNotExist() throws Exception { + Task task = createUnitTestTask("1", "DUMMY-TASK", "1"); + doThrow(TaskNotFoundException.class).when(taskMapperMock).findById(task.getId()); + + try { + cut.getTaskById(task.getId()); + } catch (Exception e) { + verify(taskanaEngineImpl, times(1)).openConnection(); + verify(taskMapperMock, times(1)).findById(task.getId()); + verify(taskanaEngineImpl, times(1)).returnConnection(); + verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, + taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); + throw e; + } } private Task createUnitTestTask(String id, String name, String workbasketId) { @@ -214,15 +574,13 @@ public class TaskServiceImplTest { Timestamp now = new Timestamp(System.currentTimeMillis()); task.setCreated(now); task.setModified(now); - Mockito.when(taskMapper.findById(any())).thenReturn(task); return task; } - private Workbasket createWorkbasket2() { - Workbasket workbasket2 = new Workbasket(); - workbasket2.setId("2"); - workbasket2.setName("Workbasket 2"); - return workbasket2; + private Workbasket createWorkbasket(String id) { + Workbasket workbasket = new Workbasket(); + workbasket.setId(id); + workbasket.setName("Workbasket " + id); + return workbasket; } - } diff --git a/lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntAutocommitTest.java b/lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntAutocommitTest.java index 2e7e816b3..b3508e4aa 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntAutocommitTest.java +++ b/lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntAutocommitTest.java @@ -21,6 +21,7 @@ import pro.taskana.TaskanaEngine.ConnectionManagementMode; import pro.taskana.configuration.TaskanaEngineConfiguration; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.TaskNotFoundException; +import pro.taskana.exceptions.WorkbasketNotFoundException; import pro.taskana.impl.ClassificationQueryImpl; import pro.taskana.impl.ObjectReferenceQueryImpl; import pro.taskana.impl.TaskServiceImpl; @@ -64,7 +65,8 @@ public class TaskServiceImplIntAutocommitTest { } @Test - public void testStart() throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException { + public void testStart() throws FileNotFoundException, SQLException, TaskNotFoundException, + WorkbasketNotFoundException, NotAuthorizedException { Task task = new Task(); task.setName("Unit Test Task"); String id1 = IdGenerator.generateWithPrefix("TWB"); @@ -80,7 +82,7 @@ public class TaskServiceImplIntAutocommitTest { @Test(expected = TaskNotFoundException.class) public void testStartTransactionFail() - throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException { + throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException, WorkbasketNotFoundException { Task task = new Task(); task.setName("Unit Test Task"); String id1 = IdGenerator.generateWithPrefix("TWB"); @@ -95,7 +97,7 @@ public class TaskServiceImplIntAutocommitTest { @Test public void testCreateTaskInTaskanaWithDefaultDb() - throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException { + throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException, WorkbasketNotFoundException { TaskanaEngineConfiguration taskanaEngineConfiguration = new TaskanaEngineConfiguration(null, false, false); TaskanaEngine te = taskanaEngineConfiguration.buildTaskanaEngine(); TaskServiceImpl taskServiceImpl = (TaskServiceImpl) te.getTaskService(); @@ -111,7 +113,7 @@ public class TaskServiceImplIntAutocommitTest { } @Test - public void should_ReturnList_when_BuilderIsUsed() throws SQLException, NotAuthorizedException { + public void should_ReturnList_when_BuilderIsUsed() throws SQLException, NotAuthorizedException, WorkbasketNotFoundException { Task task = new Task(); task.setName("Unit Test Task"); String id1 = IdGenerator.generateWithPrefix("TWB"); diff --git a/lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntExplicitTest.java b/lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntExplicitTest.java index 536354c16..292215cf2 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntExplicitTest.java +++ b/lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntExplicitTest.java @@ -23,6 +23,7 @@ import pro.taskana.TaskanaEngine.ConnectionManagementMode; import pro.taskana.configuration.TaskanaEngineConfiguration; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.TaskNotFoundException; +import pro.taskana.exceptions.WorkbasketNotFoundException; import pro.taskana.impl.ClassificationQueryImpl; import pro.taskana.impl.ObjectReferenceQueryImpl; import pro.taskana.impl.TaskServiceImpl; @@ -65,7 +66,7 @@ public class TaskServiceImplIntExplicitTest { } @Test - public void testStart() throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException { + public void testStart() throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException, WorkbasketNotFoundException { Connection connection = dataSource.getConnection(); taskanaEngineImpl.setConnection(connection); Task task = new Task(); @@ -84,7 +85,7 @@ public class TaskServiceImplIntExplicitTest { @Test(expected = TaskNotFoundException.class) public void testStartTransactionFail() - throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException { + throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException, WorkbasketNotFoundException { Connection connection = dataSource.getConnection(); taskanaEngineImpl.setConnection(connection); // taskServiceImpl = (TaskServiceImpl) taskanaEngine.getTaskService(); @@ -105,7 +106,7 @@ public class TaskServiceImplIntExplicitTest { @Test public void testCreateTaskInTaskanaWithDefaultDb() - throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException { + throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException, WorkbasketNotFoundException { DataSource ds = TaskanaEngineConfiguration.createDefaultDataSource(); TaskanaEngineConfiguration taskanaEngineConfiguration = new TaskanaEngineConfiguration(ds, false, false); TaskanaEngine te = taskanaEngineConfiguration.buildTaskanaEngine(); @@ -126,7 +127,7 @@ public class TaskServiceImplIntExplicitTest { } @Test - public void should_ReturnList_when_BuilderIsUsed() throws SQLException, NotAuthorizedException { + public void should_ReturnList_when_BuilderIsUsed() throws SQLException, NotAuthorizedException, WorkbasketNotFoundException { Connection connection = dataSource.getConnection(); taskanaEngineImpl.setConnection(connection); diff --git a/lib/taskana-spring-example/src/main/java/pro/taskana/ExampleBootstrap.java b/lib/taskana-spring-example/src/main/java/pro/taskana/ExampleBootstrap.java index 69441a333..5da6d8c54 100644 --- a/lib/taskana-spring-example/src/main/java/pro/taskana/ExampleBootstrap.java +++ b/lib/taskana-spring-example/src/main/java/pro/taskana/ExampleBootstrap.java @@ -7,6 +7,7 @@ import org.springframework.stereotype.Component; import org.springframework.transaction.annotation.Transactional; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.TaskNotFoundException; +import pro.taskana.exceptions.WorkbasketNotFoundException; import pro.taskana.model.Task; @Component @@ -17,7 +18,7 @@ public class ExampleBootstrap { private TaskService taskService; @PostConstruct - public void test() throws TaskNotFoundException, NotAuthorizedException { + public void test() throws TaskNotFoundException, NotAuthorizedException, WorkbasketNotFoundException { System.out.println("---------------------------> Start App"); Task task = new Task(); task.setName("Spring example task"); diff --git a/lib/taskana-spring/src/test/java/pro/taskana/TaskanaComponent.java b/lib/taskana-spring/src/test/java/pro/taskana/TaskanaComponent.java index da52b6251..c996899d2 100644 --- a/lib/taskana-spring/src/test/java/pro/taskana/TaskanaComponent.java +++ b/lib/taskana-spring/src/test/java/pro/taskana/TaskanaComponent.java @@ -4,6 +4,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.springframework.transaction.annotation.Transactional; import pro.taskana.exceptions.NotAuthorizedException; +import pro.taskana.exceptions.WorkbasketNotFoundException; import pro.taskana.model.Task; @Component @@ -17,7 +18,7 @@ public class TaskanaComponent { return taskService; } - public void triggerRollback() throws NotAuthorizedException { + public void triggerRollback() throws NotAuthorizedException, WorkbasketNotFoundException { Task task = new Task(); task.setName("Unit Test Task"); task.setWorkbasketId("1"); diff --git a/rest/src/main/java/pro/taskana/rest/TaskController.java b/rest/src/main/java/pro/taskana/rest/TaskController.java index 8a4cb4300..1c2e61df6 100644 --- a/rest/src/main/java/pro/taskana/rest/TaskController.java +++ b/rest/src/main/java/pro/taskana/rest/TaskController.java @@ -32,6 +32,7 @@ public class TaskController { @Autowired private TaskService taskService; + @Autowired private TaskFilter taskLogic; @@ -45,6 +46,7 @@ public class TaskController { } return ResponseEntity.status(HttpStatus.OK).body(taskLogic.inspectPrams(params)); } catch (NotAuthorizedException e) { + logger.error("Somthing went wrong whith the Authorisation, while getting all Tasks.", e); return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build(); } } @@ -55,6 +57,7 @@ public class TaskController { Task task = taskService.getTaskById(taskId); return ResponseEntity.status(HttpStatus.OK).body(task); } catch (TaskNotFoundException e) { + logger.error("The searched Task couldn´t be found or does not exist.", e); return ResponseEntity.status(HttpStatus.NOT_FOUND).build(); } } @@ -67,6 +70,7 @@ public class TaskController { Task updatedTask = taskService.getTaskById(taskId); return ResponseEntity.status(HttpStatus.OK).body(updatedTask); } catch (TaskNotFoundException e) { + logger.error("The given Task coundn´t be found/claimd or does not Exist.", e); return ResponseEntity.status(HttpStatus.NOT_FOUND).build(); } }