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

TSK-882: Local Build of taskana-core fails because of equal timestamps

This commit is contained in:
Benjamin Eckstein 2019-11-03 12:29:14 +01:00
parent be906eaedf
commit 11b5afd0f3
2 changed files with 118 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
lib/taskana-core/src/test/java/acceptance/task/CompleteTaskAccTest.java
View File

@ -7,7 +7,6 @@ import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
import java.time.Instant; import java.time.Instant;
import java.util.concurrent.TimeUnit;
import org.junit.Assert; import org.junit.Assert;
import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Assertions;
@ -36,9 +35,9 @@ import pro.taskana.security.WithAccessId;
*/ */
@ExtendWith(JAASExtension.class) @ExtendWith(JAASExtension.class)
public class CompleteTaskAccTest extends AbstractAccTest { class CompleteTaskAccTest extends AbstractAccTest {
public CompleteTaskAccTest() { CompleteTaskAccTest() {
super(); super();
} }
@ -46,7 +45,7 @@ public class CompleteTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testCompleteTask() void testCompleteTask()
throws TaskNotFoundException, InvalidStateException, InvalidOwnerException, NotAuthorizedException { throws TaskNotFoundException, InvalidStateException, InvalidOwnerException, NotAuthorizedException {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
@ -64,7 +63,7 @@ public class CompleteTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testCompleteTaskTwice() void testCompleteTaskTwice()
throws TaskNotFoundException, InvalidStateException, InvalidOwnerException, NotAuthorizedException { throws TaskNotFoundException, InvalidStateException, InvalidOwnerException, NotAuthorizedException {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
Task completedTask = taskService.completeTask("TKI:000000000000000000000000000000000002"); Task completedTask = taskService.completeTask("TKI:000000000000000000000000000000000002");
@ -76,7 +75,7 @@ public class CompleteTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testForceCompleteAlreadyClaimed() void testForceCompleteAlreadyClaimed()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException, throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException, TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
InvalidOwnerException, InvalidStateException { InvalidOwnerException, InvalidStateException {
@ -91,12 +90,11 @@ public class CompleteTaskAccTest extends AbstractAccTest {
newTaskImpl.setClaimed(Instant.now()); newTaskImpl.setClaimed(Instant.now());
Task createdTask = taskService.createTask(newTaskImpl); Task createdTask = taskService.createTask(newTaskImpl);
waitAMillisecond();
Task completedTask = taskService.forceCompleteTask(createdTask.getId()); Task completedTask = taskService.forceCompleteTask(createdTask.getId());
assertEquals(TaskState.COMPLETED, completedTask.getState()); assertEquals(TaskState.COMPLETED, completedTask.getState());
assertNotNull(completedTask.getCompleted()); assertNotNull(completedTask.getCompleted());
assertNotEquals(completedTask.getCreated(), completedTask.getModified()); assertTrue(isBeforeOrEqual(completedTask.getCreated(), completedTask.getModified()));
assertEquals(completedTask.getModified(), completedTask.getCompleted()); assertEquals(completedTask.getModified(), completedTask.getCompleted());
} }
@ -104,7 +102,7 @@ public class CompleteTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testForceCompleteNotClaimed() void testForceCompleteNotClaimed()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException, throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException, TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
InvalidOwnerException, InvalidStateException { InvalidOwnerException, InvalidStateException {
@ -118,12 +116,11 @@ public class CompleteTaskAccTest extends AbstractAccTest {
newTaskImpl.setClaimed(Instant.now()); newTaskImpl.setClaimed(Instant.now());
Task createdTask = taskService.createTask(newTaskImpl); Task createdTask = taskService.createTask(newTaskImpl);
waitAMillisecond();
Task completedTask = taskService.forceCompleteTask(createdTask.getId()); Task completedTask = taskService.forceCompleteTask(createdTask.getId());
assertEquals(TaskState.COMPLETED, completedTask.getState()); assertEquals(TaskState.COMPLETED, completedTask.getState());
assertNotNull(completedTask.getCompleted()); assertNotNull(completedTask.getCompleted());
assertNotEquals(completedTask.getCreated(), completedTask.getModified()); assertTrue(isBeforeOrEqual(completedTask.getCreated(), completedTask.getModified()));
assertEquals(completedTask.getModified(), completedTask.getCompleted()); assertEquals(completedTask.getModified(), completedTask.getCompleted());
} }
@ -131,7 +128,7 @@ public class CompleteTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testCompleteTaskThrowsErrors() { void testCompleteTaskThrowsErrors() {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
try { try {
taskService.completeTask("TKI:0000000000000000000000000000000000xx"); taskService.completeTask("TKI:0000000000000000000000000000000000xx");
@ -162,7 +159,7 @@ public class CompleteTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testClaimTaskWithDefaultFlag() void testClaimTaskWithDefaultFlag()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException, throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException, InvalidStateException, TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException, InvalidStateException,
InvalidOwnerException { InvalidOwnerException {
@ -177,26 +174,23 @@ public class CompleteTaskAccTest extends AbstractAccTest {
assertNotNull(createdTask); assertNotNull(createdTask);
assertNull(createdTask.getClaimed()); assertNull(createdTask.getClaimed());
Instant before = Instant.now(); Instant before = createdTask.getCreated();
waitAMillisecond();
Task claimedTask = taskService.claim(createdTask.getId()); Task claimedTask = taskService.claim(createdTask.getId());
waitAMillisecond();
Instant after = Instant.now();
assertNotNull(claimedTask.getOwner()); assertNotNull(claimedTask.getOwner());
assertEquals(claimedTask.getOwner(), CurrentUserContext.getUserid()); assertEquals(claimedTask.getOwner(), CurrentUserContext.getUserid());
assertNotNull(claimedTask.getClaimed()); assertNotNull(claimedTask.getClaimed());
assertTrue(claimedTask.getClaimed().isAfter(before)); assertTrue(isBeforeOrEqual(before, claimedTask.getClaimed()));
assertTrue(claimedTask.getClaimed().isBefore(after)); assertTrue(isBeforeOrEqual(claimedTask.getCreated(), claimedTask.getClaimed()));
assertTrue(claimedTask.getModified().isAfter(before)); assertTrue(isBeforeOrEqual(claimedTask.getClaimed(), Instant.now()));
assertTrue(claimedTask.getModified().isBefore(after)); assertEquals(claimedTask.getClaimed(), claimedTask.getModified());
} }
@WithAccessId( @WithAccessId(
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testForceClaimTaskFromOtherUser() void testForceClaimTaskFromOtherUser()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException, throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException, TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
InvalidStateException, InvalidOwnerException { InvalidStateException, InvalidOwnerException {
@ -212,14 +206,14 @@ public class CompleteTaskAccTest extends AbstractAccTest {
assertEquals(createdTask.getOwner(), "other_user"); assertEquals(createdTask.getOwner(), "other_user");
Instant beforeForceClaim = Instant.now(); Instant beforeForceClaim = Instant.now();
waitAMillisecond();
Task taskAfterClaim = taskService.forceClaim(createdTask.getId()); Task taskAfterClaim = taskService.forceClaim(createdTask.getId());
assertEquals(CurrentUserContext.getUserid(), taskAfterClaim.getOwner()); assertEquals(CurrentUserContext.getUserid(), taskAfterClaim.getOwner());
assertTrue(taskAfterClaim.getModified().isAfter(beforeForceClaim)); assertTrue(isBeforeOrEqual(beforeForceClaim, taskAfterClaim.getModified()));
assertTrue(taskAfterClaim.getClaimed().isAfter(beforeForceClaim)); assertTrue(isBeforeOrEqual(beforeForceClaim, taskAfterClaim.getClaimed()));
assertTrue(isBeforeOrEqual(taskAfterClaim.getCreated(), taskAfterClaim.getModified()));
assertEquals(TaskState.CLAIMED, taskAfterClaim.getState()); assertEquals(TaskState.CLAIMED, taskAfterClaim.getState());
assertNotEquals(createdTask.getCreated(), taskAfterClaim.getModified());
assertTrue(taskAfterClaim.isRead()); assertTrue(taskAfterClaim.isRead());
} }
@ -227,7 +221,7 @@ public class CompleteTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testClaimTaskNotExisting() { void testClaimTaskNotExisting() {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
Assertions.assertThrows(TaskNotFoundException.class, () -> taskService.claim("NOT_EXISTING")); Assertions.assertThrows(TaskNotFoundException.class, () -> taskService.claim("NOT_EXISTING"));
@ -237,7 +231,7 @@ public class CompleteTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testClaimTaskWithInvalidState() { void testClaimTaskWithInvalidState() {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
Assertions.assertThrows(InvalidStateException.class, () -> Assertions.assertThrows(InvalidStateException.class, () ->
@ -248,9 +242,7 @@ public class CompleteTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testClaimTaskWithInvalidOwner() void testClaimTaskWithInvalidOwner() {
throws TaskNotFoundException, InvalidStateException, InvalidOwnerException,
NotAuthorizedException {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
Assertions.assertThrows(InvalidOwnerException.class, () -> Assertions.assertThrows(InvalidOwnerException.class, () ->
@ -261,9 +253,7 @@ public class CompleteTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testCancelClaimForcedWithInvalidState() void testCancelClaimForcedWithInvalidState() {
throws TaskNotFoundException, InvalidStateException, InvalidOwnerException,
NotAuthorizedException {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
Assertions.assertThrows(InvalidStateException.class, () -> Assertions.assertThrows(InvalidStateException.class, () ->
@ -274,7 +264,7 @@ public class CompleteTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testCancelClaimDefaultFlag() void testCancelClaimDefaultFlag()
throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException, TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
InvalidStateException, InvalidOwnerException { InvalidStateException, InvalidOwnerException {
@ -298,7 +288,7 @@ public class CompleteTaskAccTest extends AbstractAccTest {
userName = "admin", userName = "admin",
groupNames = {"admin"}) groupNames = {"admin"})
@Test @Test
public void testForceCancelClaimSuccessfull() void testForceCancelClaimSuccessfull()
throws TaskNotFoundException, InvalidStateException, InvalidOwnerException, throws TaskNotFoundException, InvalidStateException, InvalidOwnerException,
NotAuthorizedException { NotAuthorizedException {
@ -328,18 +318,14 @@ public class CompleteTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testCancelClaimWithInvalidOwner() { void testCancelClaimWithInvalidOwner() {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
Assertions.assertThrows(InvalidOwnerException.class, () -> Assertions.assertThrows(InvalidOwnerException.class, () ->
taskService.cancelClaim("TKI:000000000000000000000000000000000100")); taskService.cancelClaim("TKI:000000000000000000000000000000000100"));
} }
private void waitAMillisecond() { private boolean isBeforeOrEqual(Instant before, Instant after) {
try { return before.isBefore(after) || before.equals(after);
TimeUnit.MILLISECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
} }
} }

262
lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java
View File

@ -2,10 +2,11 @@ package acceptance.task;
import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat; import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.time.Duration; import java.time.Duration;
import java.time.Instant; import java.time.Instant;
@ -13,6 +14,7 @@ import java.time.temporal.ChronoUnit;
import java.util.Collections; import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import java.util.function.Consumer;
import org.apache.ibatis.session.Configuration; import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSession;
@ -21,6 +23,7 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.ExtendWith;
import acceptance.AbstractAccTest; import acceptance.AbstractAccTest;
import pro.taskana.Attachment;
import pro.taskana.ObjectReference; import pro.taskana.ObjectReference;
import pro.taskana.Task; import pro.taskana.Task;
import pro.taskana.TaskService; import pro.taskana.TaskService;
@ -46,17 +49,13 @@ import pro.taskana.security.WithAccessId;
* Acceptance test for all "create task" scenarios. * Acceptance test for all "create task" scenarios.
*/ */
@ExtendWith(JAASExtension.class) @ExtendWith(JAASExtension.class)
public class CreateTaskAccTest extends AbstractAccTest { class CreateTaskAccTest extends AbstractAccTest {
public CreateTaskAccTest() {
super();
}
@WithAccessId( @WithAccessId(
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testCreateSimpleManualTask() void testCreateSimpleManualTask()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException, throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException { WorkbasketNotFoundException, TaskAlreadyExistException {
@ -78,22 +77,22 @@ public class CreateTaskAccTest extends AbstractAccTest {
assertNotNull(createdTask.getCreated()); assertNotNull(createdTask.getCreated());
assertNotNull(createdTask.getModified()); assertNotNull(createdTask.getModified());
assertNotNull(createdTask.getBusinessProcessId()); assertNotNull(createdTask.getBusinessProcessId());
assertEquals(null, createdTask.getClaimed()); assertNull(createdTask.getClaimed());
assertEquals(null, createdTask.getCompleted()); assertNull(createdTask.getCompleted());
assertEquals(createdTask.getCreated(), createdTask.getModified()); assertEquals(createdTask.getCreated(), createdTask.getModified());
assertEquals(createdTask.getCreated(), createdTask.getPlanned()); assertEquals(createdTask.getCreated(), createdTask.getPlanned());
assertEquals(TaskState.READY, createdTask.getState()); assertEquals(TaskState.READY, createdTask.getState());
assertEquals(null, createdTask.getParentBusinessProcessId()); assertNull(createdTask.getParentBusinessProcessId());
assertEquals(2, createdTask.getPriority()); assertEquals(2, createdTask.getPriority());
assertEquals(false, createdTask.isRead()); assertFalse(createdTask.isRead());
assertEquals(false, createdTask.isTransferred()); assertFalse(createdTask.isTransferred());
} }
@WithAccessId( @WithAccessId(
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testCreateTaskWithPlanned() void testCreateTaskWithPlanned()
throws NotAuthorizedException, InvalidArgumentException, throws NotAuthorizedException, InvalidArgumentException,
ClassificationNotFoundException, WorkbasketNotFoundException, TaskAlreadyExistException { ClassificationNotFoundException, WorkbasketNotFoundException, TaskAlreadyExistException {
@ -113,16 +112,18 @@ public class CreateTaskAccTest extends AbstractAccTest {
assertTrue(createdTask.getCreated().isBefore(createdTask.getPlanned())); assertTrue(createdTask.getCreated().isBefore(createdTask.getPlanned()));
//verify that planned takes place 2 hours after creation (+- 5 seconds) //verify that planned takes place 2 hours after creation (+- 5 seconds)
long difference = Duration.between(createdTask.getCreated(), createdTask.getPlanned()).abs().getSeconds(); Instant plannedAdjusted = createdTask.getPlanned().minus(2, ChronoUnit.HOURS);
long difference = Duration.between(createdTask.getCreated(), plannedAdjusted).abs().getSeconds();
//add some tolerance to ignore that "created" depends on execution speed //add some tolerance to ignore that "created" depends on execution speed
assertTrue(Math.abs(difference - 2 * 60 * 60) < 5); long tolerance = 5;
assertTrue(Math.abs(difference) < tolerance);
} }
@WithAccessId( @WithAccessId(
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testIdempotencyOfTaskCreation() void testIdempotencyOfTaskCreation()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException, throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException { WorkbasketNotFoundException, TaskAlreadyExistException {
@ -141,15 +142,15 @@ public class CreateTaskAccTest extends AbstractAccTest {
assertNotNull(createdTask.getCreated()); assertNotNull(createdTask.getCreated());
assertNotNull(createdTask.getModified()); assertNotNull(createdTask.getModified());
assertNotNull(createdTask.getBusinessProcessId()); assertNotNull(createdTask.getBusinessProcessId());
assertEquals(null, createdTask.getClaimed()); assertNull(createdTask.getClaimed());
assertEquals(null, createdTask.getCompleted()); assertNull(createdTask.getCompleted());
assertEquals(createdTask.getCreated(), createdTask.getModified()); assertEquals(createdTask.getCreated(), createdTask.getModified());
assertEquals(createdTask.getCreated(), createdTask.getPlanned()); assertEquals(createdTask.getCreated(), createdTask.getPlanned());
assertEquals(TaskState.READY, createdTask.getState()); assertEquals(TaskState.READY, createdTask.getState());
assertEquals(null, createdTask.getParentBusinessProcessId()); assertNull(createdTask.getParentBusinessProcessId());
assertEquals(2, createdTask.getPriority()); assertEquals(2, createdTask.getPriority());
assertEquals(false, createdTask.isRead()); assertFalse(createdTask.isRead());
assertEquals(false, createdTask.isTransferred()); assertFalse(createdTask.isTransferred());
Task newTask2 = taskService.newTask("USER_1_1", "DOMAIN_A"); Task newTask2 = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask2.setExternalId("MyExternalId"); newTask2.setExternalId("MyExternalId");
@ -164,7 +165,7 @@ public class CreateTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testCreateSimpleTaskWithCustomAttributes() void testCreateSimpleTaskWithCustomAttributes()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException, throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException, NoSuchFieldException, WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException, NoSuchFieldException,
IllegalAccessException { IllegalAccessException {
@ -183,15 +184,15 @@ public class CreateTaskAccTest extends AbstractAccTest {
assertNotNull(createdTask.getCreated()); assertNotNull(createdTask.getCreated());
assertNotNull(createdTask.getModified()); assertNotNull(createdTask.getModified());
assertNotNull(createdTask.getBusinessProcessId()); assertNotNull(createdTask.getBusinessProcessId());
assertEquals(null, createdTask.getClaimed()); assertNull(createdTask.getClaimed());
assertEquals(null, createdTask.getCompleted()); assertNull(createdTask.getCompleted());
assertEquals(createdTask.getCreated(), createdTask.getModified()); assertEquals(createdTask.getCreated(), createdTask.getModified());
assertEquals(createdTask.getCreated(), createdTask.getPlanned()); assertEquals(createdTask.getCreated(), createdTask.getPlanned());
assertEquals(TaskState.READY, createdTask.getState()); assertEquals(TaskState.READY, createdTask.getState());
assertEquals(null, createdTask.getParentBusinessProcessId()); assertNull(createdTask.getParentBusinessProcessId());
assertEquals(2, createdTask.getPriority()); assertEquals(2, createdTask.getPriority());
assertEquals(false, createdTask.isRead()); assertFalse(createdTask.isRead());
assertEquals(false, createdTask.isTransferred()); assertFalse(createdTask.isTransferred());
// verify that the database content is as expected // verify that the database content is as expected
TaskanaEngineProxyForTest engineProxy = new TaskanaEngineProxyForTest(taskanaEngine); TaskanaEngineProxyForTest engineProxy = new TaskanaEngineProxyForTest(taskanaEngine);
try { try {
@ -224,7 +225,7 @@ public class CreateTaskAccTest extends AbstractAccTest {
Task retrievedTask = taskService.getTask(createdTask.getId()); Task retrievedTask = taskService.getTask(createdTask.getId());
Map<String, String> customAttributesFromDb = retrievedTask.getCustomAttributes(); Map<String, String> customAttributesFromDb = retrievedTask.getCustomAttributes();
assertNotNull(customAttributesFromDb); assertNotNull(customAttributesFromDb);
assertTrue(customAttributesFromDb.equals(customAttributesForCreate)); assertEquals(customAttributesFromDb, customAttributesForCreate);
} }
@ -232,7 +233,7 @@ public class CreateTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testCreateExternalTaskWithAttachment() void testCreateExternalTaskWithAttachment()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException, throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException, NoSuchFieldException, WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException, NoSuchFieldException,
IllegalAccessException { IllegalAccessException {
@ -291,14 +292,14 @@ public class CreateTaskAccTest extends AbstractAccTest {
// verify that the map is correctly retrieved from the database // verify that the map is correctly retrieved from the database
Map<String, String> customAttributesFromDb = readTask.getAttachments().get(0).getCustomAttributes(); Map<String, String> customAttributesFromDb = readTask.getAttachments().get(0).getCustomAttributes();
assertNotNull(customAttributesFromDb); assertNotNull(customAttributesFromDb);
assertTrue(customAttributesFromDb.equals(customAttributesForCreate)); assertEquals(customAttributesFromDb, customAttributesForCreate);
} }
@WithAccessId( @WithAccessId(
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testCreateExternalTaskWithMultipleAttachments() void testCreateExternalTaskWithMultipleAttachments()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException, throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException { WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
@ -335,7 +336,7 @@ public class CreateTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testPrioDurationOfTaskFromAttachmentsAtCreate() void testPrioDurationOfTaskFromAttachmentsAtCreate()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException, throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException { WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
@ -368,97 +369,65 @@ public class CreateTaskAccTest extends AbstractAccTest {
// assertNotNull(readTask.getAttachments().get(0).getClassification()); // assertNotNull(readTask.getAttachments().get(0).getClassification());
assertNotNull(readTask.getAttachments().get(0).getObjectReference()); assertNotNull(readTask.getAttachments().get(0).getObjectReference());
assertTrue(readTask.getPriority() == 99); assertEquals(99, readTask.getPriority());
DaysToWorkingDaysConverter converter = DaysToWorkingDaysConverter DaysToWorkingDaysConverter converter = DaysToWorkingDaysConverter
.initialize(Collections.singletonList(new TimeIntervalColumnHeader(0)), Instant.now()); .initialize(Collections.singletonList(new TimeIntervalColumnHeader(0)), Instant.now());
long calendarDays = converter.convertWorkingDaysToDays(readTask.getPlanned(), 1); long calendarDays = converter.convertWorkingDaysToDays(readTask.getPlanned(), 1);
assertTrue(readTask.getDue().equals(readTask.getPlanned().plus(Duration.ofDays(calendarDays)))); assertEquals(readTask.getDue(), readTask.getPlanned().plus(Duration.ofDays(calendarDays)));
} }
@WithAccessId( @WithAccessId(
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testThrowsExceptionIfAttachmentIsInvalid() void testThrowsExceptionIfAttachmentIsInvalid()
throws NotAuthorizedException, ClassificationNotFoundException, throws ClassificationNotFoundException {
WorkbasketNotFoundException, TaskAlreadyExistException {
TaskService taskService = taskanaEngine.getTaskService(); Consumer<Attachment> testCreateTask = (Attachment invalidAttachment) -> {
Task newTask = makeNewTask(taskService); TaskService taskService = taskanaEngine.getTaskService();
newTask.addAttachment(createAttachment("DOCTYPE_DEFAULT", Task taskWithInvalidAttachment = makeNewTask(taskService);
taskWithInvalidAttachment.addAttachment(invalidAttachment);
Assertions.assertThrows(InvalidArgumentException.class, () ->
taskService.createTask(taskWithInvalidAttachment),
"Should have thrown an InvalidArgumentException, because Attachment-ObjRef is null.");
};
testCreateTask.accept(createAttachment("DOCTYPE_DEFAULT",
null, null,
"E-MAIL", "2018-01-15", createSimpleCustomProperties(3))); "E-MAIL", "2018-01-15", createSimpleCustomProperties(3)));
try {
taskService.createTask(newTask);
fail("Should have thrown an InvalidArgumentException, becasue Attachment-ObjRef is null.");
} catch (InvalidArgumentException ex) {
// nothing to do
}
newTask = makeNewTask(taskService); testCreateTask.accept(createAttachment("DOCTYPE_DEFAULT",
newTask.addAttachment(createAttachment("DOCTYPE_DEFAULT",
createObjectReference("COMPANY_A", "SYSTEM_B", "INSTANCE_B", "ArchiveId", null), createObjectReference("COMPANY_A", "SYSTEM_B", "INSTANCE_B", "ArchiveId", null),
"E-MAIL", "2018-01-15", createSimpleCustomProperties(3))); "E-MAIL", "2018-01-15", createSimpleCustomProperties(3)));
try {
taskService.createTask(newTask);
fail("Should have thrown an InvalidArgumentException, becasue ObjRef-Value is null.");
} catch (InvalidArgumentException ex) {
// nothing to do
}
newTask = makeNewTask(taskService); testCreateTask.accept(createAttachment("DOCTYPE_DEFAULT",
newTask.addAttachment(createAttachment("DOCTYPE_DEFAULT",
createObjectReference("COMPANY_A", "SYSTEM_B", "INSTANCE_B", null, createObjectReference("COMPANY_A", "SYSTEM_B", "INSTANCE_B", null,
"12345678901234567890123456789012345678901234567890"), "12345678901234567890123456789012345678901234567890"),
"E-MAIL", "2018-01-15", createSimpleCustomProperties(3))); "E-MAIL", "2018-01-15", createSimpleCustomProperties(3)));
try {
taskService.createTask(newTask); testCreateTask.accept(createAttachment("DOCTYPE_DEFAULT",
fail("Should have thrown an InvalidArgumentException, becasue ObjRef-Type is null.");
} catch (InvalidArgumentException ex) {
// nothing to do
}
newTask = makeNewTask(taskService);
newTask.addAttachment(createAttachment("DOCTYPE_DEFAULT",
createObjectReference("COMPANY_A", "SYSTEM_B", null, "ArchiveId", createObjectReference("COMPANY_A", "SYSTEM_B", null, "ArchiveId",
"12345678901234567890123456789012345678901234567890"), "12345678901234567890123456789012345678901234567890"),
"E-MAIL", "2018-01-15", createSimpleCustomProperties(3))); "E-MAIL", "2018-01-15", createSimpleCustomProperties(3)));
try {
taskService.createTask(newTask); testCreateTask.accept(createAttachment("DOCTYPE_DEFAULT",
fail("Should have thrown an InvalidArgumentException, becasue ObjRef-SystemInstance is null.");
} catch (InvalidArgumentException ex) {
// nothing to do
}
newTask = makeNewTask(taskService);
newTask.addAttachment(createAttachment("DOCTYPE_DEFAULT",
createObjectReference("COMPANY_A", null, "INSTANCE_B", "ArchiveId", createObjectReference("COMPANY_A", null, "INSTANCE_B", "ArchiveId",
"12345678901234567890123456789012345678901234567890"), "12345678901234567890123456789012345678901234567890"),
"E-MAIL", "2018-01-15", createSimpleCustomProperties(3))); "E-MAIL", "2018-01-15", createSimpleCustomProperties(3)));
try {
taskService.createTask(newTask); testCreateTask.accept(createAttachment("DOCTYPE_DEFAULT",
fail("Should have thrown an InvalidArgumentException, becasue ObjRef-System is null.");
} catch (InvalidArgumentException ex) {
// nothing to do
}
newTask = makeNewTask(taskService);
newTask.addAttachment(createAttachment("DOCTYPE_DEFAULT",
createObjectReference(null, "SYSTEM_B", "INSTANCE_B", "ArchiveId", createObjectReference(null, "SYSTEM_B", "INSTANCE_B", "ArchiveId",
"12345678901234567890123456789012345678901234567890"), "12345678901234567890123456789012345678901234567890"),
"E-MAIL", "2018-01-15", createSimpleCustomProperties(3))); "E-MAIL", "2018-01-15", createSimpleCustomProperties(3)));
try {
taskService.createTask(newTask);
fail("Should have thrown an InvalidArgumentException, becasue ObjRef-Company is null.");
} catch (InvalidArgumentException ex) {
// nothing to do
}
} }
@WithAccessId( @WithAccessId(
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testUseCustomNameIfSetForNewTask() void testUseCustomNameIfSetForNewTask()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException, throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException { WorkbasketNotFoundException, TaskAlreadyExistException {
@ -478,7 +447,7 @@ public class CreateTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testUseClassificationMetadataFromCorrectDomainForNewTask() void testUseClassificationMetadataFromCorrectDomainForNewTask()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException, throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException { WorkbasketNotFoundException, TaskAlreadyExistException {
@ -498,7 +467,7 @@ public class CreateTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testGetExceptionIfWorkbasketDoesNotExist() { void testGetExceptionIfWorkbasketDoesNotExist() {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("UNKNOWN"); Task newTask = taskService.newTask("UNKNOWN");
@ -513,7 +482,7 @@ public class CreateTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testGetExceptionIfAppendIsNotPermitted() { void testGetExceptionIfAppendIsNotPermitted() {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("GPK_KSC", "DOMAIN_A"); Task newTask = taskService.newTask("GPK_KSC", "DOMAIN_A");
@ -528,81 +497,33 @@ public class CreateTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testThrowsExceptionIfMandatoryPrimaryObjectReferenceIsNotSetOrIncomplete() void testThrowsExceptionIfMandatoryPrimaryObjectReferenceIsNotSetOrIncomplete() {
throws NotAuthorizedException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
TaskService taskService = taskanaEngine.getTaskService(); Consumer<ObjectReference> testCreateTask = (ObjectReference objectReference) -> {
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A"); TaskService taskService = taskanaEngine.getTaskService();
newTask.setClassificationKey("T2100"); Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
try { newTask.setClassificationKey("T2100");
taskService.createTask(newTask); if (objectReference != null) {
fail("Should have thrown an InvalidArgumentException, because ObjRef is null."); newTask.setPrimaryObjRef(objectReference);
} catch (InvalidArgumentException ex) { }
// nothing to do Assertions.assertThrows(InvalidArgumentException.class, () ->
} taskService.createTask(newTask),
"Should have thrown an InvalidArgumentException, because ObjRef-ObjRef is null.");
};
// Exception testCreateTask.accept(null);
newTask = taskService.newTask("USER_1_1", "DOMAIN_A"); testCreateTask.accept(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", null));
newTask.setClassificationKey("T2100"); testCreateTask.accept(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", null, "1234567"));
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", null)); testCreateTask.accept(createObjectReference("COMPANY_A", "SYSTEM_A", null, "VNR", "1234567"));
try { testCreateTask.accept(createObjectReference("COMPANY_A", null, "INSTANCE_A", "VNR", "1234567"));
taskService.createTask(newTask); testCreateTask.accept(createObjectReference(null, "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
fail("Should have thrown an InvalidArgumentException, becasue ObjRef-Value is null.");
} catch (InvalidArgumentException ex) {
// nothing to do
}
// Exception
newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", null, "1234567"));
try {
taskService.createTask(newTask);
fail("Should have thrown an InvalidArgumentException, becasue ObjRef-Type is null.");
} catch (InvalidArgumentException ex) {
// nothing to do
}
// Exception
newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", null, "VNR", "1234567"));
try {
taskService.createTask(newTask);
fail("Should have thrown an InvalidArgumentException, becasue ObjRef-SystemInstances is null.");
} catch (InvalidArgumentException ex) {
// nothing to do
}
// Exception
newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", null, "INSTANCE_A", "VNR", "1234567"));
try {
taskService.createTask(newTask);
fail("Should have thrown an InvalidArgumentException, becasue ObjRef-System is null.");
} catch (InvalidArgumentException ex) {
// nothing to do
}
// Exception
newTask = taskService.newTask("WBI:100000000000000000000000000000000006");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(createObjectReference(null, "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
try {
taskService.createTask(newTask);
fail("Should have thrown an InvalidArgumentException, becasue ObjRef-Company is null.");
} catch (InvalidArgumentException ex) {
// nothing to do
}
} }
@WithAccessId( @WithAccessId(
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testSetDomainFromWorkbasket() void testSetDomainFromWorkbasket()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException, throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException { WorkbasketNotFoundException, TaskAlreadyExistException {
@ -626,7 +547,7 @@ public class CreateTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testCreatedTaskObjectEqualsReadTaskObject() void testCreatedTaskObjectEqualsReadTaskObject()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException, throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException { WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
@ -654,7 +575,7 @@ public class CreateTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testCreateSimpleTaskWithCallbackInfo() void testCreateSimpleTaskWithCallbackInfo()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException, throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException { TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException {
@ -675,15 +596,15 @@ public class CreateTaskAccTest extends AbstractAccTest {
assertNotNull(createdTask.getCreated()); assertNotNull(createdTask.getCreated());
assertNotNull(createdTask.getModified()); assertNotNull(createdTask.getModified());
assertNotNull(createdTask.getBusinessProcessId()); assertNotNull(createdTask.getBusinessProcessId());
assertEquals(null, createdTask.getClaimed()); assertNull(createdTask.getClaimed());
assertEquals(null, createdTask.getCompleted()); assertNull(createdTask.getCompleted());
assertEquals(createdTask.getCreated(), createdTask.getModified()); assertEquals(createdTask.getCreated(), createdTask.getModified());
assertEquals(createdTask.getCreated(), createdTask.getPlanned()); assertEquals(createdTask.getCreated(), createdTask.getPlanned());
assertEquals(TaskState.READY, createdTask.getState()); assertEquals(TaskState.READY, createdTask.getState());
assertEquals(null, createdTask.getParentBusinessProcessId()); assertNull(createdTask.getParentBusinessProcessId());
assertEquals(2, createdTask.getPriority()); assertEquals(2, createdTask.getPriority());
assertEquals(false, createdTask.isRead()); assertFalse(createdTask.isRead());
assertEquals(false, createdTask.isTransferred()); assertFalse(createdTask.isTransferred());
Task retrievedTask = taskService.getTask(createdTask.getId()); Task retrievedTask = taskService.getTask(createdTask.getId());
assertEquals(callbackInfo, retrievedTask.getCallbackInfo()); assertEquals(callbackInfo, retrievedTask.getCallbackInfo());
@ -691,9 +612,7 @@ public class CreateTaskAccTest extends AbstractAccTest {
} }
@Test @Test
public void testCreateTaskWithSecurityButNoUserId() void testCreateTaskWithSecurityButNoUserId() {
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A"); Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
@ -708,9 +627,8 @@ public class CreateTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testCreateTaskAlreadyExisting() void testCreateTaskAlreadyExisting()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException, throws NotAuthorizedException, TaskNotFoundException {
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
Task existingTask = taskService.getTask("TKI:000000000000000000000000000000000000"); Task existingTask = taskService.getTask("TKI:000000000000000000000000000000000000");
@ -723,9 +641,7 @@ public class CreateTaskAccTest extends AbstractAccTest {
userName = "user_1_1", userName = "user_1_1",
groupNames = {"group_1"}) groupNames = {"group_1"})
@Test @Test
public void testCreateTaskNotAuthorizedOnWorkbasket() throws WorkbasketNotFoundException, void testCreateTaskNotAuthorizedOnWorkbasket() {
ClassificationNotFoundException, NotAuthorizedException, TaskAlreadyExistException,
InvalidArgumentException {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.newTask("TEAMLEAD_2", "DOMAIN_A"); Task task = taskService.newTask("TEAMLEAD_2", "DOMAIN_A");