nosu
/
taskana
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

TSK-21: Conflicts resolved (merge)

This commit is contained in:
Marcel Lengl 2017-11-30 14:03:01 +01:00
parent 142d801ab1 29e2c67dab
commit f166b648ce
11 changed files with 499 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lib/taskana-cdi-example/src/main/java/pro/taskana/ExampleBootstrap.java
View File

@ -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());

3
lib/taskana-cdi/src/test/java/pro/taskana/TaskanaEjb.java
View File

@ -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();

5
lib/taskana-cdi/src/test/java/pro/taskana/TaskanaRestTest.java
View File

@ -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();
}

8
lib/taskana-core/src/main/java/pro/taskana/TaskService.java
View File

@ -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.

14
lib/taskana-core/src/main/java/pro/taskana/impl/TaskServiceImpl.java
View File

@ -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);

560
lib/taskana-core/src/test/java/pro/taskana/impl/TaskServiceImplTest.java
View File

@ -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<TaskState> taskStates = Arrays.asList(TaskState.CLAIMED, TaskState.COMPLETED);
List<TaskStateCounter> expectedResult = new ArrayList<>();
doReturn(expectedResult).when(taskMapperMock).getTaskCountForState(taskStates);
Task readTask = taskServiceImpl.setTaskRead("1", true);
Assert.assertTrue(readTask.isRead());
List<TaskStateCounter> 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<TaskState> 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<TaskState> taskStates = Arrays.asList(TaskState.CLAIMED, TaskState.COMPLETED);
List<DueWorkbasketCounter> expectedResult = new ArrayList<>();
doReturn(expectedResult).when(taskMapperMock).getTaskCountByWorkbasketIdAndDaysInPastAndState(any(Date.class), any());
List<DueWorkbasketCounter> 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;
}
}

10
lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntAutocommitTest.java
View File

@ -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");

9
lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntExplicitTest.java
View File

@ -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);

3
lib/taskana-spring-example/src/main/java/pro/taskana/ExampleBootstrap.java
View File

@ -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");

3
lib/taskana-spring/src/test/java/pro/taskana/TaskanaComponent.java
View File

@ -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");

4
rest/src/main/java/pro/taskana/rest/TaskController.java
View File

@ -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();
}
}