TSK-815: Removed duplicated and moved functionality testing into acceptance test
This commit is contained in:
julian.schallenmueller
Holger Hagen
parent
cbc2ff16ac
commit
4a7664f9ef
|
|
@ -199,7 +199,7 @@ public class ClassificationQueryImpl implements ClassificationQuery {
|
|||
num = Integer.parseInt(number);
|
||||
} catch (NumberFormatException e) {
|
||||
throw new InvalidArgumentException(
|
||||
"Argument '" + number + "' to getCustomAttribute cannot be converted to a number between 1 and 16",
|
||||
"Argument '" + number + "' to getCustomAttribute cannot be converted to a number between 1 and 8",
|
||||
e.getCause());
|
||||
}
|
||||
if (customIn.length == 0) {
|
||||
|
|
|
|||
|
|
@ -1,8 +1,10 @@
|
|||
package acceptance.classification;
|
||||
|
||||
import static org.hamcrest.core.IsEqual.equalTo;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertNotNull;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
|
|
@ -15,6 +17,8 @@ import pro.taskana.exceptions.ClassificationNotFoundException;
|
|||
import pro.taskana.exceptions.DomainNotFoundException;
|
||||
import pro.taskana.exceptions.InvalidArgumentException;
|
||||
import pro.taskana.exceptions.NotAuthorizedException;
|
||||
import pro.taskana.exceptions.TaskanaException;
|
||||
import pro.taskana.impl.ClassificationImpl;
|
||||
import pro.taskana.security.JAASRunner;
|
||||
import pro.taskana.security.WithAccessId;
|
||||
|
||||
|
|
@ -24,6 +28,8 @@ import pro.taskana.security.WithAccessId;
|
|||
@RunWith(JAASRunner.class)
|
||||
public class CreateClassificationAccTest extends AbstractAccTest {
|
||||
|
||||
private static final String ID_PREFIX_CLASSIFICATION = "CLI";
|
||||
|
||||
private ClassificationService classificationService;
|
||||
|
||||
public CreateClassificationAccTest() {
|
||||
|
|
@ -53,6 +59,7 @@ public class CreateClassificationAccTest extends AbstractAccTest {
|
|||
assertNotNull(classification.getModified());
|
||||
assertNotNull(classification.getId());
|
||||
assertThat(classification.getIsValidInDomain(), equalTo(false));
|
||||
assertTrue(classification.getId().startsWith(ID_PREFIX_CLASSIFICATION));
|
||||
}
|
||||
|
||||
@WithAccessId(
|
||||
|
|
@ -74,6 +81,7 @@ public class CreateClassificationAccTest extends AbstractAccTest {
|
|||
assertNotNull(createdClassification.getModified());
|
||||
assertThat(createdClassification.getIsValidInDomain(), equalTo(true));
|
||||
assertThat(createdClassification.getDomain(), equalTo("DOMAIN_A"));
|
||||
assertEquals(createdClassification.getKey(), "Key1");
|
||||
|
||||
// Check 2 new created
|
||||
long amountOfClassificationsAfter = classificationService.createClassificationQuery().count();
|
||||
|
|
@ -86,6 +94,7 @@ public class CreateClassificationAccTest extends AbstractAccTest {
|
|||
assertNotNull(classification.getModified());
|
||||
assertNotNull(classification.getId());
|
||||
assertThat(classification.getIsValidInDomain(), equalTo(true));
|
||||
assertTrue(classification.getId().startsWith(ID_PREFIX_CLASSIFICATION));
|
||||
|
||||
// Check master-copy
|
||||
classification = classificationService.getClassification(classification.getKey(), "");
|
||||
|
|
@ -94,6 +103,51 @@ public class CreateClassificationAccTest extends AbstractAccTest {
|
|||
assertNotNull(classification.getModified());
|
||||
assertNotNull(classification.getId());
|
||||
assertThat(classification.getIsValidInDomain(), equalTo(false));
|
||||
assertTrue(classification.getId().startsWith(ID_PREFIX_CLASSIFICATION));
|
||||
}
|
||||
|
||||
@WithAccessId(
|
||||
userName = "teamlead_1",
|
||||
groupNames = {"group_1", "businessadmin"})
|
||||
@Test
|
||||
public void testCreateClassificationWithExistingMaster()
|
||||
throws DomainNotFoundException, ClassificationAlreadyExistException,
|
||||
NotAuthorizedException, InvalidArgumentException {
|
||||
|
||||
classificationService.createClassification(
|
||||
classificationService.newClassification("Key0815", "", "TASK"));
|
||||
|
||||
long amountOfClassificationsBefore = classificationService.createClassificationQuery().count();
|
||||
Classification expected = classificationService.newClassification("Key0815", "DOMAIN_B", "TASK");
|
||||
Classification actual = classificationService.createClassification(expected);
|
||||
long amountOfClassificationsAfter = classificationService.createClassificationQuery().count();
|
||||
|
||||
assertEquals(amountOfClassificationsBefore + 1, amountOfClassificationsAfter);
|
||||
assertNotNull(actual);
|
||||
assertEquals(actual, expected);
|
||||
assertTrue(actual.getIsValidInDomain());
|
||||
}
|
||||
|
||||
@WithAccessId(
|
||||
userName = "teamlead_1",
|
||||
groupNames = {"group_1", "businessadmin"})
|
||||
@Test
|
||||
public void testCreateChildInDomainAndCopyInMaster()
|
||||
throws DomainNotFoundException, ClassificationAlreadyExistException,
|
||||
TaskanaException, InvalidArgumentException {
|
||||
Classification parent = classificationService.newClassification("Key0816", "DOMAIN_A", "TASK");
|
||||
Classification actualParent = classificationService.createClassification(parent);
|
||||
assertNotNull(actualParent);
|
||||
|
||||
long amountOfClassificationsBefore = classificationService.createClassificationQuery().count();
|
||||
Classification child = classificationService.newClassification("Key0817", "DOMAIN_A", "TASK");
|
||||
child.setParentId(actualParent.getId());
|
||||
child.setParentKey(actualParent.getKey());
|
||||
Classification actualChild = classificationService.createClassification(child);
|
||||
long amountOfClassificationsAfter = classificationService.createClassificationQuery().count();
|
||||
|
||||
assertEquals(amountOfClassificationsBefore + 2, amountOfClassificationsAfter);
|
||||
assertNotNull(actualChild);
|
||||
}
|
||||
|
||||
@WithAccessId(
|
||||
|
|
@ -192,4 +246,17 @@ public class CreateClassificationAccTest extends AbstractAccTest {
|
|||
classification = classificationService.createClassification(classification);
|
||||
}
|
||||
|
||||
@WithAccessId(
|
||||
userName = "teamlead_1",
|
||||
groupNames = {"group_1", "businessadmin"})
|
||||
@Test(expected = InvalidArgumentException.class)
|
||||
public void testCreateClassificationWithExplicitId()
|
||||
throws DomainNotFoundException, ClassificationAlreadyExistException,
|
||||
NotAuthorizedException, InvalidArgumentException {
|
||||
ClassificationImpl classification = (ClassificationImpl) classificationService
|
||||
.newClassification("Key0818", "", "TASK");
|
||||
classification.setId("EXPLICIT ID");
|
||||
classificationService.createClassification(classification);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,13 +18,15 @@ import pro.taskana.exceptions.ClassificationNotFoundException;
|
|||
*/
|
||||
public class GetClassificationAccTest extends AbstractAccTest {
|
||||
|
||||
private ClassificationService classificationService;
|
||||
|
||||
public GetClassificationAccTest() {
|
||||
super();
|
||||
classificationService = taskanaEngine.getClassificationService();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindAllClassifications() {
|
||||
ClassificationService classificationService = taskanaEngine.getClassificationService();
|
||||
List<ClassificationSummary> classificationSummaryList = classificationService.createClassificationQuery()
|
||||
.list();
|
||||
assertNotNull(classificationSummaryList);
|
||||
|
|
@ -32,7 +34,6 @@ public class GetClassificationAccTest extends AbstractAccTest {
|
|||
|
||||
@Test
|
||||
public void testGetOneClassificationByKeyAndDomain() throws ClassificationNotFoundException {
|
||||
ClassificationService classificationService = taskanaEngine.getClassificationService();
|
||||
Classification classification = classificationService.getClassification("T6310", "DOMAIN_A");
|
||||
assertNotNull(classification);
|
||||
assertEquals("CLI:100000000000000000000000000000000011", classification.getId());
|
||||
|
|
@ -56,7 +57,6 @@ public class GetClassificationAccTest extends AbstractAccTest {
|
|||
|
||||
@Test
|
||||
public void testGetOneClassificationById() throws ClassificationNotFoundException {
|
||||
ClassificationService classificationService = taskanaEngine.getClassificationService();
|
||||
Classification classification = classificationService
|
||||
.getClassification("CLI:100000000000000000000000000000000011");
|
||||
assertNotNull(classification);
|
||||
|
|
@ -82,7 +82,6 @@ public class GetClassificationAccTest extends AbstractAccTest {
|
|||
|
||||
@Test
|
||||
public void testGetClassificationAsSummary() throws ClassificationNotFoundException {
|
||||
ClassificationService classificationService = taskanaEngine.getClassificationService();
|
||||
ClassificationSummary classification = classificationService
|
||||
.getClassification("CLI:100000000000000000000000000000000011").asSummary();
|
||||
assertNotNull(classification);
|
||||
|
|
@ -99,16 +98,25 @@ public class GetClassificationAccTest extends AbstractAccTest {
|
|||
|
||||
@Test(expected = ClassificationNotFoundException.class)
|
||||
public void testGetOneClassificationByIdFails() throws ClassificationNotFoundException {
|
||||
ClassificationService classificationService = taskanaEngine.getClassificationService();
|
||||
Classification classification = classificationService
|
||||
.getClassification("CLI:100000000470000000000000000000000011");
|
||||
classificationService.getClassification("CLI:100000000470000000000000000000000011");
|
||||
fail("ClassificationNotFoundException was expected");
|
||||
}
|
||||
|
||||
@Test(expected = ClassificationNotFoundException.class)
|
||||
public void testGetClassificationByNullKeyFails() throws ClassificationNotFoundException {
|
||||
classificationService.getClassification(null, "");
|
||||
fail("ClassificationNotFoundException was expected");
|
||||
}
|
||||
|
||||
@Test(expected = ClassificationNotFoundException.class)
|
||||
public void testGetClassificationByInvalidKeyAndDomain() throws ClassificationNotFoundException {
|
||||
classificationService.getClassification("Key0815", "NOT_EXISTING");
|
||||
fail("ClassificationNotFoundException was expected");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetOneClassificationForDomainAndGetClassificationFromMasterDomain()
|
||||
throws ClassificationNotFoundException {
|
||||
ClassificationService classificationService = taskanaEngine.getClassificationService();
|
||||
Classification classification = classificationService.getClassification("L10000", "DOMAIN_B");
|
||||
assertNotNull(classification);
|
||||
assertEquals("", classification.getDomain());
|
||||
|
|
@ -117,7 +125,6 @@ public class GetClassificationAccTest extends AbstractAccTest {
|
|||
|
||||
@Test
|
||||
public void testGetOneClassificationForMasterDomain() throws ClassificationNotFoundException {
|
||||
ClassificationService classificationService = taskanaEngine.getClassificationService();
|
||||
Classification classification = classificationService.getClassification("L10000", "");
|
||||
assertNotNull(classification);
|
||||
assertEquals("", classification.getDomain());
|
||||
|
|
|
|||
|
|
@ -399,6 +399,15 @@ public class QueryClassificationAccTest extends AbstractAccTest {
|
|||
assertEquals(3, results.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testQueryForCustom2Like() throws InvalidArgumentException {
|
||||
ClassificationService classificationService = taskanaEngine.getClassificationService();
|
||||
List<ClassificationSummary> results = classificationService.createClassificationQuery()
|
||||
.customAttributeLike("2", "cus%")
|
||||
.list();
|
||||
assertEquals(4, results.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testQueryForCustom3Like() throws InvalidArgumentException {
|
||||
ClassificationService classificationService = taskanaEngine.getClassificationService();
|
||||
|
|
|
|||
|
|
@ -22,8 +22,10 @@ import pro.taskana.Classification;
|
|||
import pro.taskana.ClassificationService;
|
||||
import pro.taskana.Task;
|
||||
import pro.taskana.TaskService;
|
||||
import pro.taskana.exceptions.ClassificationAlreadyExistException;
|
||||
import pro.taskana.exceptions.ClassificationNotFoundException;
|
||||
import pro.taskana.exceptions.ConcurrencyException;
|
||||
import pro.taskana.exceptions.DomainNotFoundException;
|
||||
import pro.taskana.exceptions.InvalidArgumentException;
|
||||
import pro.taskana.exceptions.NotAuthorizedException;
|
||||
import pro.taskana.exceptions.TaskNotFoundException;
|
||||
|
|
@ -40,8 +42,11 @@ import pro.taskana.security.WithAccessId;
|
|||
@RunWith(JAASRunner.class)
|
||||
public class UpdateClassificationAccTest extends AbstractAccTest {
|
||||
|
||||
private ClassificationService classificationService;
|
||||
|
||||
public UpdateClassificationAccTest() {
|
||||
super();
|
||||
classificationService = taskanaEngine.getClassificationService();
|
||||
}
|
||||
|
||||
@WithAccessId(
|
||||
|
|
@ -53,7 +58,6 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
|
|||
InvalidArgumentException {
|
||||
String newName = "updated Name";
|
||||
String newEntryPoint = "updated EntryPoint";
|
||||
ClassificationService classificationService = taskanaEngine.getClassificationService();
|
||||
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
|
||||
Instant createdBefore = classification.getCreated();
|
||||
Instant modifiedBefore = classification.getModified();
|
||||
|
|
@ -93,7 +97,6 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
|
|||
InvalidArgumentException {
|
||||
String newName = "updated Name";
|
||||
String newEntryPoint = "updated EntryPoint";
|
||||
ClassificationService classificationService = taskanaEngine.getClassificationService();
|
||||
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
|
||||
|
||||
classification.setApplicationEntryPoint(newEntryPoint);
|
||||
|
|
@ -126,7 +129,7 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
|
|||
TaskImpl beforeTask = (TaskImpl) taskanaEngine.getTaskService()
|
||||
.getTask("TKI:000000000000000000000000000000000000");
|
||||
|
||||
Classification classification = taskanaEngine.getClassificationService()
|
||||
Classification classification = classificationService
|
||||
.getClassification(beforeTask.getClassificationSummary().getKey(), beforeTask.getDomain());
|
||||
classification.setCategory("PROCESS");
|
||||
Instant createdBefore = classification.getCreated();
|
||||
|
|
@ -153,7 +156,6 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
|
|||
public void testUpdateClassificationNotLatestAnymore()
|
||||
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException, InterruptedException,
|
||||
InvalidArgumentException {
|
||||
ClassificationService classificationService = taskanaEngine.getClassificationService();
|
||||
Classification base = classificationService.getClassification("T2100", "DOMAIN_A");
|
||||
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
|
||||
|
||||
|
|
@ -177,7 +179,6 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
|
|||
public void testUpdateClassificationParentIdToInvalid()
|
||||
throws NotAuthorizedException, ClassificationNotFoundException,
|
||||
ConcurrencyException, InvalidArgumentException {
|
||||
ClassificationService classificationService = taskanaEngine.getClassificationService();
|
||||
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
|
||||
classification.setParentId("ID WHICH CANT BE FOUND");
|
||||
classification = classificationService.updateClassification(classification);
|
||||
|
|
@ -190,7 +191,6 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
|
|||
public void testUpdateClassificationParentKeyToInvalid()
|
||||
throws NotAuthorizedException, ClassificationNotFoundException,
|
||||
ConcurrencyException, InvalidArgumentException {
|
||||
ClassificationService classificationService = taskanaEngine.getClassificationService();
|
||||
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
|
||||
classification.setParentKey("KEY WHICH CANT BE FOUND");
|
||||
classification = classificationService.updateClassification(classification);
|
||||
|
|
@ -205,7 +205,6 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
|
|||
InterruptedException, TaskNotFoundException, InvalidArgumentException {
|
||||
String newEntryPoint = "updated EntryPoint";
|
||||
Instant before = Instant.now();
|
||||
ClassificationService classificationService = taskanaEngine.getClassificationService();
|
||||
Classification classification = classificationService
|
||||
.getClassification("CLI:100000000000000000000000000000000003");
|
||||
Instant createdBefore = classification.getCreated();
|
||||
|
|
@ -283,13 +282,27 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
|
|||
public void testUpdateClassificationWithSameKeyAndParentKey()
|
||||
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException, InvalidArgumentException {
|
||||
|
||||
ClassificationService classificationService = taskanaEngine.getClassificationService();
|
||||
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
|
||||
|
||||
classification.setParentKey(classification.getKey());
|
||||
classificationService.updateClassification(classification);
|
||||
}
|
||||
|
||||
|
||||
@WithAccessId(
|
||||
userName = "dummy",
|
||||
groupNames = {"businessadmin"})
|
||||
@Test
|
||||
public void testUpdateClassificationWithEmptyServiceLevel()
|
||||
throws DomainNotFoundException, ClassificationAlreadyExistException, NotAuthorizedException,
|
||||
InvalidArgumentException, ClassificationNotFoundException, ConcurrencyException {
|
||||
|
||||
Classification classification = classificationService.newClassification("Key=0818", "DOMAIN_A", "TASK");
|
||||
Classification created = classificationService.createClassification(classification);
|
||||
created.setServiceLevel("");
|
||||
classificationService.updateClassification(created);
|
||||
}
|
||||
|
||||
private void validateNewTaskProperties(Instant before, List<String> tasksWithP15D, TaskService taskService,
|
||||
DaysToWorkingDaysConverter converter, int serviceLevel) throws TaskNotFoundException, NotAuthorizedException {
|
||||
for (String taskId : tasksWithP15D) {
|
||||
|
|
|
|||
|
|
@ -1,18 +1,11 @@
|
|||
package pro.taskana.impl;
|
||||
|
||||
import static junit.framework.TestCase.assertEquals;
|
||||
import static org.hamcrest.CoreMatchers.equalTo;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.mockito.ArgumentMatchers.any;
|
||||
import static org.mockito.Mockito.doNothing;
|
||||
import static org.mockito.Mockito.doReturn;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.verifyNoMoreInteractions;
|
||||
|
||||
import java.time.Instant;
|
||||
import java.time.LocalDate;
|
||||
import java.util.List;
|
||||
|
||||
|
|
@ -28,8 +21,6 @@ import org.mockito.junit.MockitoJUnitRunner;
|
|||
import pro.taskana.Classification;
|
||||
import pro.taskana.JobService;
|
||||
import pro.taskana.exceptions.ClassificationAlreadyExistException;
|
||||
import pro.taskana.exceptions.ClassificationNotFoundException;
|
||||
import pro.taskana.exceptions.ConcurrencyException;
|
||||
import pro.taskana.exceptions.DomainNotFoundException;
|
||||
import pro.taskana.exceptions.InvalidArgumentException;
|
||||
import pro.taskana.exceptions.NotAuthorizedException;
|
||||
|
|
@ -72,344 +63,6 @@ public class ClassificationServiceImplTest {
|
|||
doNothing().when(taskanaEngineImplMock).returnConnection();
|
||||
}
|
||||
|
||||
@Test(expected = ClassificationAlreadyExistException.class)
|
||||
public void testCreateClassificationAlreadyExisting()
|
||||
throws ClassificationAlreadyExistException, NotAuthorizedException,
|
||||
DomainNotFoundException, InvalidArgumentException {
|
||||
Classification classification = createDummyClassification();
|
||||
doReturn(classification).when(classificationMapperMock).findByKeyAndDomain(classification.getKey(),
|
||||
classification.getDomain());
|
||||
doReturn(true).when(taskanaEngineImplMock).domainExists(any());
|
||||
|
||||
try {
|
||||
cutSpy.createClassification(classification);
|
||||
} catch (ClassificationAlreadyExistException e) {
|
||||
verify(taskanaEngineImplMock, times(1)).openConnection();
|
||||
verify(classificationMapperMock, times(1)).findByKeyAndDomain(classification.getKey(),
|
||||
classification.getDomain());
|
||||
verify(taskanaEngineImplMock, times(1)).returnConnection();
|
||||
verify(taskanaEngineImplMock, times(1)).checkRoleMembership(any());
|
||||
verify(taskanaEngineImplMock, times(1)).domainExists(any());
|
||||
verifyNoMoreInteractions(classificationMapperMock, taskanaEngineImplMock, classificationQueryImplMock);
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
@Test(expected = InvalidArgumentException.class)
|
||||
public void testCreateClassificationParentIdNotExisting()
|
||||
throws ClassificationAlreadyExistException, ClassificationNotFoundException, NotAuthorizedException,
|
||||
DomainNotFoundException, InvalidArgumentException {
|
||||
Classification classification = createDummyClassification(null);
|
||||
classification.setParentId("NOT EXISTING ID");
|
||||
doReturn(null).when(classificationMapperMock).findByKeyAndDomain(classification.getKey(),
|
||||
classification.getDomain());
|
||||
doReturn(null).when(classificationMapperMock).findById(classification.getParentId());
|
||||
doReturn(true).when(taskanaEngineImplMock).domainExists(any());
|
||||
|
||||
try {
|
||||
cutSpy.createClassification(classification);
|
||||
} catch (InvalidArgumentException e) {
|
||||
verify(taskanaEngineImplMock, times(1)).checkRoleMembership(any());
|
||||
verify(taskanaEngineImplMock, times(2)).openConnection();
|
||||
verify(classificationMapperMock, times(1)).findByKeyAndDomain(classification.getKey(),
|
||||
classification.getDomain());
|
||||
verify(cutSpy, times(1)).getClassification(classification.getParentId());
|
||||
verify(classificationMapperMock, times(1)).findById(classification.getParentId());
|
||||
verify(taskanaEngineImplMock, times(2)).returnConnection();
|
||||
verify(taskanaEngineImplMock, times(1)).domainExists(any());
|
||||
verifyNoMoreInteractions(classificationMapperMock, taskanaEngineImplMock, classificationQueryImplMock);
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
@Test(expected = InvalidArgumentException.class)
|
||||
public void testCreateClassificationParentKeyNotExisting()
|
||||
throws ClassificationAlreadyExistException, ClassificationNotFoundException, NotAuthorizedException,
|
||||
DomainNotFoundException, InvalidArgumentException {
|
||||
Classification classification = createDummyClassification(null);
|
||||
classification.setParentKey("NOT EXISTING KEY");
|
||||
doReturn(null).when(classificationMapperMock).findByKeyAndDomain(classification.getKey(),
|
||||
classification.getDomain());
|
||||
doReturn(null).when(classificationMapperMock).findByKeyAndDomain(classification.getParentKey(),
|
||||
classification.getDomain());
|
||||
doReturn(true).when(taskanaEngineImplMock).domainExists(any());
|
||||
|
||||
try {
|
||||
cutSpy.createClassification(classification);
|
||||
} catch (InvalidArgumentException e) {
|
||||
verify(taskanaEngineImplMock, times(1)).checkRoleMembership(any());
|
||||
verify(taskanaEngineImplMock, times(2)).openConnection();
|
||||
verify(classificationMapperMock, times(1)).findByKeyAndDomain(classification.getKey(),
|
||||
classification.getDomain());
|
||||
verify(classificationMapperMock, times(1)).findByKeyAndDomain(classification.getParentKey(),
|
||||
classification.getDomain());
|
||||
verify(classificationMapperMock, times(1)).findByKeyAndDomain(classification.getParentKey(), "");
|
||||
verify(cutSpy, times(1)).getClassification(classification.getParentKey(), classification.getDomain());
|
||||
verify(taskanaEngineImplMock, times(2)).returnConnection();
|
||||
verify(taskanaEngineImplMock, times(1)).domainExists(any());
|
||||
verifyNoMoreInteractions(classificationMapperMock, taskanaEngineImplMock, classificationQueryImplMock);
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCreateClassificationInOwnDomainButExistingInMaster()
|
||||
throws ClassificationAlreadyExistException, InterruptedException,
|
||||
NotAuthorizedException, DomainNotFoundException, InvalidArgumentException {
|
||||
Instant beforeTimestamp = Instant.now();
|
||||
Thread.sleep(10L);
|
||||
Classification classification = createDummyClassification(null);
|
||||
String domain = classification.getDomain();
|
||||
String key = classification.getKey();
|
||||
doReturn(null).when(classificationMapperMock).findByKeyAndDomain(classification.getKey(),
|
||||
classification.getDomain());
|
||||
doReturn(classification).when(classificationMapperMock).findByKeyAndDomain(classification.getKey(), "");
|
||||
doReturn(true).when(taskanaEngineImplMock).domainExists(any());
|
||||
|
||||
classification = cutSpy.createClassification(classification);
|
||||
|
||||
Thread.sleep(10L);
|
||||
verify(taskanaEngineImplMock, times(2)).openConnection();
|
||||
verify(classificationMapperMock, times(1)).findByKeyAndDomain(key, domain);
|
||||
verify(classificationMapperMock, times(1)).findByKeyAndDomain(key, "");
|
||||
verify(classificationMapperMock, times(1)).insert(any());
|
||||
verify(taskanaEngineImplMock, times(2)).returnConnection();
|
||||
verify(taskanaEngineImplMock, times(1)).checkRoleMembership(any());
|
||||
verify(taskanaEngineImplMock, times(1)).domainExists(any());
|
||||
verifyNoMoreInteractions(classificationMapperMock, taskanaEngineImplMock, classificationQueryImplMock);
|
||||
Thread.sleep(15);
|
||||
assertThat(classification.getCreated().toString().substring(0, 10), equalTo(todaysDate));
|
||||
assertFalse(classification.getCreated().isAfter(Instant.now()));
|
||||
assertTrue(classification.getCreated().isAfter(beforeTimestamp));
|
||||
assertThat(classification.getDomain(), equalTo(domain));
|
||||
assertThat(classification.getKey(), equalTo(key));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCreateClassificationInOwnDomainAndCopyInMasterDomain()
|
||||
throws ClassificationAlreadyExistException, NotAuthorizedException, DomainNotFoundException,
|
||||
InvalidArgumentException {
|
||||
Classification classification = createDummyClassification("");
|
||||
String domain = classification.getDomain();
|
||||
String key = classification.getKey();
|
||||
doReturn(null).when(classificationMapperMock).findByKeyAndDomain(classification.getKey(),
|
||||
classification.getDomain());
|
||||
doReturn(null).when(classificationMapperMock).findByKeyAndDomain(classification.getKey(), "");
|
||||
doReturn(true).when(taskanaEngineImplMock).domainExists(any());
|
||||
|
||||
classification = cutSpy.createClassification(classification);
|
||||
|
||||
verify(taskanaEngineImplMock, times(2)).openConnection();
|
||||
verify(classificationMapperMock, times(1)).findByKeyAndDomain(key, domain);
|
||||
verify(classificationMapperMock, times(2)).findByKeyAndDomain(key, "");
|
||||
verify(classificationMapperMock, times(2)).insert(any());
|
||||
verify(taskanaEngineImplMock, times(2)).returnConnection();
|
||||
verify(taskanaEngineImplMock, times(1)).checkRoleMembership(any());
|
||||
verify(taskanaEngineImplMock, times(1)).domainExists(any());
|
||||
verifyNoMoreInteractions(classificationMapperMock, taskanaEngineImplMock, classificationQueryImplMock);
|
||||
assertThat(classification.getCreated().toString().substring(0, 10), equalTo(todaysDate));
|
||||
assertThat(classification.getDomain(), equalTo(domain));
|
||||
assertThat(classification.getKey(), equalTo(key));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCreateChildClassificationInOwnDomainAndCopyInMasterDomain()
|
||||
throws ClassificationAlreadyExistException, NotAuthorizedException, DomainNotFoundException,
|
||||
InvalidArgumentException {
|
||||
Classification classification = createDummyClassification("");
|
||||
classification.setParentId("parentId");
|
||||
classification.setParentKey("ParentKey");
|
||||
ClassificationImpl parentDomainClassification = (ClassificationImpl) createDummyClassification("ParentId");
|
||||
parentDomainClassification.setKey("ParentKey");
|
||||
ClassificationImpl parentMasterClassification = (ClassificationImpl) createDummyClassification(
|
||||
"ParentIdMaster");
|
||||
parentMasterClassification.setKey("ParentKey");
|
||||
parentMasterClassification.setDomain("");
|
||||
doReturn(null).when(classificationMapperMock).findByKeyAndDomain(classification.getKey(),
|
||||
classification.getDomain());
|
||||
doReturn(null).when(classificationMapperMock).findByKeyAndDomain(classification.getKey(), "");
|
||||
doReturn(parentMasterClassification).when(classificationMapperMock).findByKeyAndDomain("ParentKey", "");
|
||||
|
||||
doReturn(parentDomainClassification).when(classificationMapperMock).findById("parentId");
|
||||
doReturn(true).when(taskanaEngineImplMock).domainExists(any());
|
||||
|
||||
cutSpy.createClassification(classification);
|
||||
|
||||
verify(classificationMapperMock, times(2)).insert(any());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCreateClassificationIntoRootDomain()
|
||||
throws ClassificationAlreadyExistException, NotAuthorizedException,
|
||||
DomainNotFoundException, InvalidArgumentException {
|
||||
ClassificationImpl classification = (ClassificationImpl) createDummyClassification(null);
|
||||
classification.setDomain("");
|
||||
doReturn(null).when(classificationMapperMock).findByKeyAndDomain(classification.getKey(),
|
||||
classification.getDomain());
|
||||
|
||||
classification = (ClassificationImpl) cutSpy.createClassification(classification);
|
||||
|
||||
verify(taskanaEngineImplMock, times(1)).openConnection();
|
||||
verify(classificationMapperMock, times(1)).findByKeyAndDomain(classification.getKey(),
|
||||
classification.getDomain());
|
||||
verify(classificationMapperMock, times(1)).insert(classification);
|
||||
verify(taskanaEngineImplMock, times(1)).returnConnection();
|
||||
verify(taskanaEngineImplMock, times(1)).checkRoleMembership(any());
|
||||
verify(taskanaEngineImplMock, times(1)).domainExists(any());
|
||||
verifyNoMoreInteractions(classificationMapperMock, taskanaEngineImplMock, classificationQueryImplMock);
|
||||
assertThat(classification.getCreated().toString().substring(0, 10), equalTo(todaysDate));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUpdateExistingClassification()
|
||||
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException, InvalidArgumentException {
|
||||
Instant now = Instant.now();
|
||||
Classification classification = createDummyClassification();
|
||||
((ClassificationImpl) classification).setModified(now);
|
||||
ClassificationImpl oldClassification = (ClassificationImpl) createDummyClassification();
|
||||
oldClassification.setModified(now);
|
||||
doReturn(oldClassification).when(cutSpy).getClassification(classification.getKey(), classification.getDomain());
|
||||
|
||||
classification = cutSpy.updateClassification(classification);
|
||||
|
||||
verify(taskanaEngineImplMock, times(1)).openConnection();
|
||||
verify(cutSpy, times(1)).getClassification(classification.getKey(), classification.getDomain());
|
||||
verify(classificationMapperMock, times(1)).update(any());
|
||||
verify(taskanaEngineImplMock, times(1)).checkRoleMembership(any());
|
||||
verify(taskanaEngineImplMock, times(1)).returnConnection();
|
||||
verifyNoMoreInteractions(classificationMapperMock, taskanaEngineImplMock, classificationQueryImplMock);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUpdateClassificationWithEmptyServiceLevel()
|
||||
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException, InvalidArgumentException {
|
||||
Instant now = Instant.now();
|
||||
Classification classification = createDummyClassification();
|
||||
((ClassificationImpl) classification).setModified(now);
|
||||
classification.setServiceLevel("");
|
||||
ClassificationImpl oldClassification = (ClassificationImpl) createDummyClassification();
|
||||
oldClassification.setModified(now);
|
||||
doReturn(oldClassification).when(cutSpy).getClassification(classification.getKey(), classification.getDomain());
|
||||
doReturn(jobServiceMock).when(taskanaEngineImplMock).getJobService();
|
||||
|
||||
cutSpy.updateClassification(classification);
|
||||
|
||||
verify(classificationMapperMock, times(1)).update(any());
|
||||
}
|
||||
|
||||
@Test(expected = ClassificationNotFoundException.class)
|
||||
public void testUpdateClassificationParentIdNotExisting()
|
||||
throws ClassificationNotFoundException, NotAuthorizedException,
|
||||
ConcurrencyException, InvalidArgumentException {
|
||||
Instant now = Instant.now();
|
||||
ClassificationImpl oldClassification = (ClassificationImpl) createDummyClassification();
|
||||
oldClassification.setParentId("SOME ID");
|
||||
oldClassification.setCreated(now);
|
||||
oldClassification.setModified(now);
|
||||
Classification classification = createDummyClassification();
|
||||
classification.setParentId("DIFFERENT ID - FOR CHECKING PARENT");
|
||||
((ClassificationImpl) classification).setCreated(oldClassification.getCreated());
|
||||
((ClassificationImpl) classification).setModified(oldClassification.getModified());
|
||||
doReturn(oldClassification).when(cutSpy).getClassification(classification.getKey(), classification.getDomain());
|
||||
doReturn(null).when(classificationMapperMock).findById(classification.getParentId());
|
||||
|
||||
try {
|
||||
cutSpy.updateClassification(classification);
|
||||
} catch (ClassificationNotFoundException e) {
|
||||
verify(taskanaEngineImplMock, times(1)).checkRoleMembership(any());
|
||||
verify(taskanaEngineImplMock, times(2)).openConnection();
|
||||
verify(cutSpy, times(1)).getClassification(classification.getKey(),
|
||||
classification.getDomain());
|
||||
verify(cutSpy, times(1)).getClassification(classification.getParentId());
|
||||
verify(classificationMapperMock, times(1)).findById(classification.getParentId());
|
||||
verify(taskanaEngineImplMock, times(2)).returnConnection();
|
||||
verifyNoMoreInteractions(classificationMapperMock, taskanaEngineImplMock, classificationQueryImplMock);
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
@Test(expected = ClassificationNotFoundException.class)
|
||||
public void testUpdateClassificationParentKeyNotExisting()
|
||||
throws ClassificationNotFoundException, NotAuthorizedException,
|
||||
ConcurrencyException, InvalidArgumentException {
|
||||
Instant now = Instant.now();
|
||||
ClassificationImpl oldClassification = (ClassificationImpl) createDummyClassification();
|
||||
oldClassification.setParentKey("SOME KEY");
|
||||
oldClassification.setCreated(now);
|
||||
oldClassification.setModified(now);
|
||||
Classification classification = createDummyClassification();
|
||||
classification.setParentKey("DIFFERENT KEY - FOR CHECKING PARENT");
|
||||
((ClassificationImpl) classification).setCreated(oldClassification.getCreated());
|
||||
((ClassificationImpl) classification).setModified(oldClassification.getModified());
|
||||
doReturn(oldClassification).when(cutSpy).getClassification(classification.getKey(), classification.getDomain());
|
||||
doReturn(null).when(classificationMapperMock).findByKeyAndDomain(classification.getParentKey(),
|
||||
classification.getDomain());
|
||||
|
||||
try {
|
||||
cutSpy.updateClassification(classification);
|
||||
} catch (ClassificationNotFoundException e) {
|
||||
verify(taskanaEngineImplMock, times(1)).checkRoleMembership(any());
|
||||
verify(taskanaEngineImplMock, times(2)).openConnection();
|
||||
verify(cutSpy, times(1)).getClassification(classification.getKey(),
|
||||
classification.getDomain());
|
||||
verify(cutSpy, times(1)).getClassification(classification.getParentKey(),
|
||||
classification.getDomain());
|
||||
verify(classificationMapperMock, times(1)).findByKeyAndDomain(classification.getParentKey(),
|
||||
classification.getDomain());
|
||||
verify(classificationMapperMock, times(1)).findByKeyAndDomain(classification.getParentKey(), "");
|
||||
verify(taskanaEngineImplMock, times(2)).returnConnection();
|
||||
verifyNoMoreInteractions(classificationMapperMock, taskanaEngineImplMock, classificationQueryImplMock);
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetClassificationFromDomain() throws ClassificationNotFoundException {
|
||||
Classification expectedClassification = createDummyClassification();
|
||||
doReturn(expectedClassification).when(classificationMapperMock)
|
||||
.findByKeyAndDomain(expectedClassification.getKey(), expectedClassification.getDomain());
|
||||
|
||||
Classification actualClassification = cutSpy.getClassification(expectedClassification.getKey(),
|
||||
expectedClassification.getDomain());
|
||||
|
||||
verify(taskanaEngineImplMock, times(1)).openConnection();
|
||||
verify(classificationMapperMock, times(1)).findByKeyAndDomain(expectedClassification.getKey(),
|
||||
expectedClassification.getDomain());
|
||||
verify(taskanaEngineImplMock, times(1)).returnConnection();
|
||||
verifyNoMoreInteractions(classificationMapperMock, taskanaEngineImplMock, classificationQueryImplMock);
|
||||
assertThat(actualClassification, equalTo(expectedClassification));
|
||||
}
|
||||
|
||||
@Test(expected = ClassificationNotFoundException.class)
|
||||
public void testGetClassificationThrowingNotFoundException() throws ClassificationNotFoundException {
|
||||
Classification classification = createDummyClassification();
|
||||
doReturn(null).when(classificationMapperMock).findByKeyAndDomain(classification.getKey(),
|
||||
classification.getDomain());
|
||||
doReturn(null).when(classificationMapperMock).findByKeyAndDomain(classification.getKey(), "");
|
||||
|
||||
try {
|
||||
cutSpy.getClassification(classification.getKey(), classification.getDomain());
|
||||
} catch (ClassificationNotFoundException e) {
|
||||
verify(taskanaEngineImplMock, times(1)).openConnection();
|
||||
verify(classificationMapperMock, times(1)).findByKeyAndDomain(classification.getKey(),
|
||||
classification.getDomain());
|
||||
verify(classificationMapperMock, times(1)).findByKeyAndDomain(classification.getKey(), "");
|
||||
verify(taskanaEngineImplMock, times(1)).returnConnection();
|
||||
verifyNoMoreInteractions(classificationMapperMock, taskanaEngineImplMock, classificationQueryImplMock);
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
@Test(expected = ClassificationNotFoundException.class)
|
||||
public void testGetClassificationWithInvalidNullKey() throws ClassificationNotFoundException {
|
||||
try {
|
||||
cutSpy.getClassification(null, "domain");
|
||||
} catch (ClassificationNotFoundException e) {
|
||||
verifyNoMoreInteractions(classificationMapperMock, taskanaEngineImplMock, classificationQueryImplMock);
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCreateClassificationQuery() {
|
||||
cutSpy.createClassificationQuery();
|
||||
|
|
@ -428,7 +81,6 @@ public class ClassificationServiceImplTest {
|
|||
assertEquals(e.getMessage(), "ClassificationId should be null on creation");
|
||||
throw e;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
private Classification createDummyClassification() {
|
||||
|
|
|
|||
|
|
@ -1,10 +1,6 @@
|
|||
package pro.taskana.impl.integration;
|
||||
|
||||
import static org.hamcrest.CoreMatchers.equalTo;
|
||||
import static org.hamcrest.core.IsNot.not;
|
||||
import static org.hamcrest.core.StringStartsWith.startsWith;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.junit.Assert.fail;
|
||||
|
||||
import java.sql.SQLException;
|
||||
import java.time.Instant;
|
||||
|
|
@ -34,7 +30,6 @@ import pro.taskana.exceptions.ConcurrencyException;
|
|||
import pro.taskana.exceptions.DomainNotFoundException;
|
||||
import pro.taskana.exceptions.InvalidArgumentException;
|
||||
import pro.taskana.exceptions.NotAuthorizedException;
|
||||
import pro.taskana.impl.ClassificationImpl;
|
||||
import pro.taskana.impl.TaskanaEngineImpl;
|
||||
import pro.taskana.impl.configuration.DBCleaner;
|
||||
import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest;
|
||||
|
|
@ -46,7 +41,6 @@ import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest;
|
|||
*/
|
||||
public class ClassificationServiceImplIntAutoCommitTest {
|
||||
|
||||
private static final String ID_PREFIX_CLASSIFICATION = "CLI";
|
||||
static int counter = 0;
|
||||
private DataSource dataSource;
|
||||
private ClassificationService classificationService;
|
||||
|
|
@ -74,84 +68,6 @@ public class ClassificationServiceImplIntAutoCommitTest {
|
|||
cleaner.clearDb(dataSource, false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInsertClassifications() throws Exception {
|
||||
final String domain = "DOMAIN_A";
|
||||
final String key = "dummy-key";
|
||||
ClassificationImpl expectedClassification;
|
||||
Classification actualClassification;
|
||||
Classification actualClassification2;
|
||||
|
||||
// empty classification (master)
|
||||
expectedClassification = (ClassificationImpl) this.createDummyClassificationWithUniqueKey("", "TASK");
|
||||
expectedClassification = (ClassificationImpl) classificationService
|
||||
.createClassification(expectedClassification);
|
||||
actualClassification = classificationService.getClassification(expectedClassification.getKey(),
|
||||
expectedClassification.getDomain());
|
||||
assertThat(actualClassification, not(equalTo(null)));
|
||||
assertThat(actualClassification.getCreated(), not(equalTo(null)));
|
||||
assertThat(actualClassification.getId(), not(equalTo(null)));
|
||||
assertThat(actualClassification.getId(), startsWith(ID_PREFIX_CLASSIFICATION));
|
||||
|
||||
// specific to domain + master
|
||||
expectedClassification = (ClassificationImpl) this.createDummyClassificationWithUniqueKey(domain, "TASK");
|
||||
expectedClassification.setKey(key);
|
||||
expectedClassification = (ClassificationImpl) classificationService
|
||||
.createClassification(expectedClassification);
|
||||
actualClassification = classificationService.getClassification(expectedClassification.getKey(),
|
||||
expectedClassification.getDomain());
|
||||
actualClassification2 = classificationService.getClassification(expectedClassification.getKey(), "");
|
||||
assertThat(actualClassification, not(equalTo(null)));
|
||||
assertThat(actualClassification.getCreated(), not(equalTo(null)));
|
||||
assertThat(actualClassification.getId(), not(equalTo(null)));
|
||||
assertThat(actualClassification.getKey(), equalTo(key));
|
||||
assertThat(actualClassification.getDomain(), equalTo(domain));
|
||||
assertThat(actualClassification.getId(), startsWith(ID_PREFIX_CLASSIFICATION));
|
||||
assertThat(actualClassification2, not(equalTo(null)));
|
||||
assertThat(actualClassification2.getCreated(), not(equalTo(null)));
|
||||
assertThat(actualClassification2.getId(), not(equalTo(null)));
|
||||
assertThat(actualClassification2.getId(), not(equalTo(actualClassification.getId())));
|
||||
assertThat(actualClassification2.getKey(), equalTo(key));
|
||||
assertThat(actualClassification2.getDomain(), equalTo(""));
|
||||
assertThat(actualClassification2.getId(), startsWith(ID_PREFIX_CLASSIFICATION));
|
||||
|
||||
// does exist already
|
||||
try {
|
||||
expectedClassification = (ClassificationImpl) this.createDummyClassificationWithUniqueKey(domain, "TASK");
|
||||
expectedClassification.setKey(key);
|
||||
classificationService.createClassification(expectedClassification);
|
||||
fail("Should have thrown 'ClassificationAlreadyExistException' here.");
|
||||
} catch (ClassificationAlreadyExistException e) {
|
||||
}
|
||||
|
||||
// new classification but master existing
|
||||
expectedClassification = (ClassificationImpl) this.createDummyClassificationWithUniqueKey("DOMAIN_B",
|
||||
"TASK");
|
||||
expectedClassification.setKey(key);
|
||||
classificationService.createClassification(expectedClassification);
|
||||
actualClassification = classificationService.getClassification(key, "DOMAIN_B");
|
||||
assertThat(actualClassification, not(equalTo(null)));
|
||||
assertThat(actualClassification.getCreated(), not(equalTo(null)));
|
||||
assertThat(actualClassification.getId(), not(equalTo(null)));
|
||||
assertThat(actualClassification.getKey(), equalTo(key));
|
||||
assertThat(actualClassification.getDomain(), equalTo("DOMAIN_B"));
|
||||
assertThat(actualClassification.getId(), startsWith(ID_PREFIX_CLASSIFICATION));
|
||||
// verify that
|
||||
Classification masterResults = classificationService.getClassification(key, "");
|
||||
assertThat(masterResults, not(equalTo(null)));
|
||||
|
||||
// invalid serviceLevel
|
||||
try {
|
||||
expectedClassification = (ClassificationImpl) this.createDummyClassificationWithUniqueKey(domain,
|
||||
"TASK");
|
||||
expectedClassification.setKey("");
|
||||
expectedClassification.setServiceLevel("ASAP");
|
||||
classificationService.createClassification(expectedClassification);
|
||||
fail("Should have thrown IllegalArgumentException, because ServiceLevel is invalid.");
|
||||
} catch (InvalidArgumentException e) {
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindAllClassifications()
|
||||
throws ClassificationAlreadyExistException, NotAuthorizedException, DomainNotFoundException,
|
||||
|
|
@ -183,7 +99,7 @@ public class ClassificationServiceImplIntAutoCommitTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testInsertAndClassificationMapper()
|
||||
public void testInsertClassification()
|
||||
throws NotAuthorizedException, ClassificationAlreadyExistException, InvalidArgumentException,
|
||||
DomainNotFoundException {
|
||||
Classification classification = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "TASK");
|
||||
|
|
@ -198,7 +114,7 @@ public class ClassificationServiceImplIntAutoCommitTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testUpdateAndClassificationMapper()
|
||||
public void testUpdateClassification()
|
||||
throws NotAuthorizedException, ClassificationAlreadyExistException, ClassificationNotFoundException,
|
||||
ConcurrencyException, DomainNotFoundException, InvalidArgumentException {
|
||||
Classification classification = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "TASK");
|
||||
|
|
@ -221,142 +137,7 @@ public class ClassificationServiceImplIntAutoCommitTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testFindWithClassificationMapperDomainAndCategory()
|
||||
throws ClassificationAlreadyExistException, NotAuthorizedException, DomainNotFoundException,
|
||||
InvalidArgumentException {
|
||||
Classification classification1 = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "TASK");
|
||||
classification1.setCategory("EXTERNAL");
|
||||
classificationService.createClassification(classification1);
|
||||
Classification classification2 = this.createDummyClassificationWithUniqueKey("DOMAIN_B", "TASK");
|
||||
classification2.setCategory("EXTERNAL");
|
||||
classificationService.createClassification(classification2);
|
||||
Classification classification3 = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "TASK");
|
||||
classification3.setCategory("MANUAL");
|
||||
classificationService.createClassification(classification3);
|
||||
|
||||
List<ClassificationSummary> list = classificationService.createClassificationQuery()
|
||||
.categoryIn("EXTERNAL")
|
||||
.domainIn("DOMAIN_A")
|
||||
.list();
|
||||
Assert.assertEquals(1, list.size());
|
||||
list = classificationService.createClassificationQuery().domainIn("DOMAIN_A", "DOMAIN_C").list();
|
||||
Assert.assertEquals(2, list.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindWithClassificationMapperCustomAndCategory()
|
||||
throws ClassificationAlreadyExistException, NotAuthorizedException, DomainNotFoundException,
|
||||
InvalidArgumentException {
|
||||
Classification classification1 = this.createDummyClassificationWithUniqueKey("", "TASK");
|
||||
classification1.setDescription("DESC1");
|
||||
classification1.setCategory("EXTERNAL");
|
||||
classificationService.createClassification(classification1);
|
||||
Classification classification2 = this.createDummyClassificationWithUniqueKey("", "TASK");
|
||||
classification2.setDescription("DESC1");
|
||||
classification2.setCustom1("custom1");
|
||||
classification2.setCategory("EXTERNAL");
|
||||
classificationService.createClassification(classification2);
|
||||
Classification classification3 = this.createDummyClassificationWithUniqueKey("", "TASK");
|
||||
classification3.setCustom1("custom2");
|
||||
classification3.setCustom2("custom1");
|
||||
classification3.setCategory("MANUAL");
|
||||
classificationService.createClassification(classification3);
|
||||
Classification classification4 = this.createDummyClassificationWithUniqueKey("", "TASK");
|
||||
classification4.setDescription("description2");
|
||||
classification4.setCustom8("custom2");
|
||||
classification4.setCategory("EXTERNAL");
|
||||
classificationService.createClassification(classification4);
|
||||
|
||||
List<ClassificationSummary> list = classificationService.createClassificationQuery()
|
||||
.descriptionLike("DESC1")
|
||||
.customAttributeIn("1", "custom1")
|
||||
.list();
|
||||
Assert.assertEquals(1, list.size());
|
||||
list = classificationService.createClassificationQuery().customAttributeIn("2", "custom1").list();
|
||||
Assert.assertEquals(1, list.size());
|
||||
list = classificationService.createClassificationQuery()
|
||||
.descriptionLike("DESC1")
|
||||
.categoryIn("EXTERNAL")
|
||||
.list();
|
||||
Assert.assertEquals(2, list.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindWithClassificationMapperPriorityTypeAndParent()
|
||||
throws ClassificationAlreadyExistException, NumberFormatException, NotAuthorizedException,
|
||||
DomainNotFoundException, InvalidArgumentException {
|
||||
Classification classification = this.createDummyClassificationWithUniqueKey("", "TASK");
|
||||
classification.setPriority(Integer.decode("5"));
|
||||
classificationService.createClassification(classification);
|
||||
Classification classification1 = this.createDummyClassificationWithUniqueKey("", "TASK");
|
||||
classification1.setPriority(Integer.decode("3"));
|
||||
classification1.setParentId(classification.getId());
|
||||
classificationService.createClassification(classification1);
|
||||
Classification classification2 = this.createDummyClassificationWithUniqueKey("", "DOCUMENT");
|
||||
classification2.setPriority(Integer.decode("5"));
|
||||
classification2.setParentId(classification.getId());
|
||||
classificationService.createClassification(classification2);
|
||||
|
||||
Classification classification3 = this.createDummyClassificationWithUniqueKey("", "TASK");
|
||||
classification3.setPriority(Integer.decode("5"));
|
||||
classification3.setParentId(classification1.getId());
|
||||
classificationService.createClassification(classification3);
|
||||
|
||||
List<ClassificationSummary> list = classificationService.createClassificationQuery()
|
||||
.parentIdIn(classification.getId())
|
||||
.list();
|
||||
Assert.assertEquals(2, list.size());
|
||||
list = classificationService.createClassificationQuery().typeIn("TASK").priorityIn(Integer.decode("5")).list();
|
||||
Assert.assertEquals(2, list.size());
|
||||
list = classificationService.createClassificationQuery()
|
||||
.priorityIn(Integer.decode("5"))
|
||||
.typeIn("TASK")
|
||||
.parentIdIn(classification1.getId())
|
||||
.list();
|
||||
Assert.assertEquals(1, list.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindWithClassificationMapperServiceLevelNameAndDescription()
|
||||
throws ClassificationAlreadyExistException, NotAuthorizedException, DomainNotFoundException,
|
||||
InvalidArgumentException {
|
||||
int all = 0;
|
||||
Classification classification = this.createDummyClassificationWithUniqueKey("", "TASK");
|
||||
classification.setServiceLevel("P1D");
|
||||
classification.setName("name1");
|
||||
classification.setDescription("desc");
|
||||
classificationService.createClassification(classification);
|
||||
all++;
|
||||
Classification classification1 = this.createDummyClassificationWithUniqueKey("", "TASK");
|
||||
classification1.setServiceLevel("P2D");
|
||||
classification1.setName("name1");
|
||||
classification1.setDescription("desc");
|
||||
classificationService.createClassification(classification1);
|
||||
all++;
|
||||
Classification classification2 = this.createDummyClassificationWithUniqueKey("", "TASK");
|
||||
classification2.setServiceLevel("P1D");
|
||||
classification2.setName("name");
|
||||
classification2.setDescription("desc");
|
||||
classificationService.createClassification(classification2);
|
||||
all++;
|
||||
Classification classification3 = this.createDummyClassificationWithUniqueKey("", "TASK");
|
||||
classification3.setName("name1");
|
||||
classification3.setDescription("description");
|
||||
classificationService.createClassification(classification3);
|
||||
all++;
|
||||
|
||||
List<ClassificationSummary> list = classificationService.createClassificationQuery().nameIn("name").list();
|
||||
Assert.assertEquals(1, list.size());
|
||||
list = classificationService.createClassificationQuery().serviceLevelIn("P1D").descriptionLike("desc").list();
|
||||
Assert.assertEquals(2, list.size());
|
||||
list = classificationService.createClassificationQuery().serviceLevelIn("P2D").nameIn("name").list();
|
||||
Assert.assertEquals(0, list.size());
|
||||
list = classificationService.createClassificationQuery().descriptionLike("desc%").list();
|
||||
Assert.assertEquals(all, list.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDefaultSettingsWithClassificationMapper()
|
||||
public void testDefaultSettings()
|
||||
throws NotAuthorizedException, ClassificationAlreadyExistException, ClassificationNotFoundException,
|
||||
ConcurrencyException, DomainNotFoundException, InvalidArgumentException {
|
||||
Classification classification = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "TASK");
|
||||
|
|
|
|||
|
|
@ -88,52 +88,6 @@ public class ClassificationServiceImplIntExplicitTest {
|
|||
final String key = "dummy-key";
|
||||
ClassificationImpl expectedClassification;
|
||||
Classification actualClassification;
|
||||
Classification actualClassification2;
|
||||
|
||||
// empty classification (master)
|
||||
expectedClassification = (ClassificationImpl) this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
expectedClassification = (ClassificationImpl) classificationService
|
||||
.createClassification(expectedClassification);
|
||||
connection.commit();
|
||||
actualClassification = classificationService.getClassification(expectedClassification.getKey(),
|
||||
expectedClassification.getDomain());
|
||||
assertThat(actualClassification, not(equalTo(null)));
|
||||
assertThat(actualClassification.getCreated(), not(equalTo(null)));
|
||||
assertThat(actualClassification.getId(), not(equalTo(null)));
|
||||
assertThat(actualClassification.getId(), startsWith(ID_PREFIX_CLASSIFICATION));
|
||||
|
||||
// specific to domain + master
|
||||
expectedClassification = (ClassificationImpl) this.createNewClassificationWithUniqueKey(domain, "TASK");
|
||||
expectedClassification.setKey(key);
|
||||
expectedClassification = (ClassificationImpl) classificationService
|
||||
.createClassification(expectedClassification);
|
||||
connection.commit();
|
||||
actualClassification = classificationService.getClassification(expectedClassification.getKey(),
|
||||
expectedClassification.getDomain());
|
||||
actualClassification2 = classificationService.getClassification(expectedClassification.getKey(), "");
|
||||
assertThat(actualClassification, not(equalTo(null)));
|
||||
assertThat(actualClassification.getCreated(), not(equalTo(null)));
|
||||
assertThat(actualClassification.getId(), not(equalTo(null)));
|
||||
assertThat(actualClassification.getKey(), equalTo(key));
|
||||
assertThat(actualClassification.getDomain(), equalTo(domain));
|
||||
assertThat(actualClassification.getId(), startsWith(ID_PREFIX_CLASSIFICATION));
|
||||
assertThat(actualClassification2, not(equalTo(null)));
|
||||
assertThat(actualClassification2.getCreated(), not(equalTo(null)));
|
||||
assertThat(actualClassification2.getId(), not(equalTo(null)));
|
||||
assertThat(actualClassification2.getId(), not(equalTo(actualClassification.getId())));
|
||||
assertThat(actualClassification2.getKey(), equalTo(key));
|
||||
assertThat(actualClassification2.getDomain(), equalTo(""));
|
||||
assertThat(actualClassification2.getId(), startsWith(ID_PREFIX_CLASSIFICATION));
|
||||
|
||||
// does exist already
|
||||
try {
|
||||
expectedClassification = (ClassificationImpl) this.createNewClassificationWithUniqueKey(domain, "TASK");
|
||||
expectedClassification.setKey(key);
|
||||
classificationService.createClassification(expectedClassification);
|
||||
connection.commit();
|
||||
fail("Should have thrown 'ClassificationAlreadyExistException' here.");
|
||||
} catch (ClassificationAlreadyExistException e) {
|
||||
}
|
||||
|
||||
// new classification but master existing
|
||||
expectedClassification = (ClassificationImpl) this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
|
|
@ -247,153 +201,6 @@ public class ClassificationServiceImplIntExplicitTest {
|
|||
connection.commit();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindWithClassificationMapperDomainAndCategory()
|
||||
throws SQLException, ClassificationAlreadyExistException, NotAuthorizedException,
|
||||
DomainNotFoundException, InvalidArgumentException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
Classification classification1 = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
|
||||
classification1.setCategory("EXTERNAL");
|
||||
classificationService.createClassification(classification1);
|
||||
Classification classification2 = this.createNewClassificationWithUniqueKey("DOMAIN_B", "TASK");
|
||||
classification2.setCategory("EXTERNAL");
|
||||
classificationService.createClassification(classification2);
|
||||
|
||||
Classification classification3 = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
|
||||
classification3.setCategory("MANUAL");
|
||||
classificationService.createClassification(classification3);
|
||||
|
||||
List<ClassificationSummary> list = classificationService.createClassificationQuery()
|
||||
.categoryIn("EXTERNAL")
|
||||
.domainIn("DOMAIN_A")
|
||||
.list();
|
||||
Assert.assertEquals(1, list.size());
|
||||
list = classificationService.createClassificationQuery().domainIn("DOMAIN_A", "domain3").list();
|
||||
Assert.assertEquals(2, list.size());
|
||||
connection.commit();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindWithClassificationMapperCustomAndCategory()
|
||||
throws SQLException, ClassificationAlreadyExistException, NotAuthorizedException,
|
||||
DomainNotFoundException, InvalidArgumentException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
Classification classification1 = this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
classification1.setDescription("DESC1");
|
||||
classification1.setCategory("EXTERNAL");
|
||||
classificationService.createClassification(classification1);
|
||||
Classification classification2 = this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
classification2.setDescription("DESC1");
|
||||
classification2.setCustom1("custom1");
|
||||
classification2.setCategory("EXTERNAL");
|
||||
classificationService.createClassification(classification2);
|
||||
Classification classification3 = this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
classification3.setCustom1("custom2");
|
||||
classification3.setCustom2("custom1");
|
||||
classification3.setCategory("MANUAL");
|
||||
classificationService.createClassification(classification3);
|
||||
Classification classification4 = this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
classification4.setDescription("description2");
|
||||
classification4.setCustom8("custom2");
|
||||
classification4.setCategory("EXTERNAL");
|
||||
classificationService.createClassification(classification4);
|
||||
|
||||
List<ClassificationSummary> list = classificationService.createClassificationQuery()
|
||||
.descriptionLike("DESC1")
|
||||
.customAttributeIn("1", "custom1")
|
||||
.list();
|
||||
Assert.assertEquals(1, list.size());
|
||||
list = classificationService.createClassificationQuery().customAttributeIn("1", "custom2").list();
|
||||
Assert.assertEquals(1, list.size());
|
||||
list = classificationService.createClassificationQuery()
|
||||
.descriptionLike("DESC1")
|
||||
.categoryIn("EXTERNAL")
|
||||
.list();
|
||||
Assert.assertEquals(2, list.size());
|
||||
connection.commit();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindWithClassificationMapperPriorityTypeAndParent()
|
||||
throws SQLException, ClassificationAlreadyExistException, NotAuthorizedException,
|
||||
DomainNotFoundException, InvalidArgumentException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
Classification classification = this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
classification.setPriority(Integer.decode("5"));
|
||||
classificationService.createClassification(classification);
|
||||
Classification classification1 = this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
classification1.setPriority(Integer.decode("3"));
|
||||
classification1.setParentId(classification.getId());
|
||||
classificationService.createClassification(classification1);
|
||||
Classification classification2 = this.createNewClassificationWithUniqueKey("", "DOCUMENT");
|
||||
classification2.setPriority(Integer.decode("5"));
|
||||
classification2.setParentId(classification.getId());
|
||||
classificationService.createClassification(classification2);
|
||||
Classification classification3 = this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
classification3.setPriority(Integer.decode("5"));
|
||||
classification3.setParentId(classification1.getId());
|
||||
classificationService.createClassification(classification3);
|
||||
|
||||
List<ClassificationSummary> list = classificationService.createClassificationQuery()
|
||||
.parentIdIn(classification.getId())
|
||||
.list();
|
||||
Assert.assertEquals(2, list.size());
|
||||
list = classificationService.createClassificationQuery().typeIn("TASK").priorityIn(Integer.decode("5")).list();
|
||||
Assert.assertEquals(2, list.size());
|
||||
list = classificationService.createClassificationQuery()
|
||||
.priorityIn(Integer.decode("5"))
|
||||
.typeIn("TASK")
|
||||
.parentIdIn(classification1.getId())
|
||||
.list();
|
||||
Assert.assertEquals(1, list.size());
|
||||
connection.commit();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindWithClassificationMapperServiceLevelNameAndDescription()
|
||||
throws NotAuthorizedException, SQLException, ClassificationAlreadyExistException,
|
||||
DomainNotFoundException, InvalidArgumentException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
int all = 0;
|
||||
Classification classification = this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
classification.setServiceLevel("P1D");
|
||||
classification.setName("name1");
|
||||
classification.setDescription("desc");
|
||||
classificationService.createClassification(classification);
|
||||
all++;
|
||||
Classification classification1 = this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
classification1.setServiceLevel("P2D");
|
||||
classification1.setName("name1");
|
||||
classification1.setDescription("desc");
|
||||
classificationService.createClassification(classification1);
|
||||
all++;
|
||||
Classification classification2 = this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
classification2.setServiceLevel("P1D");
|
||||
classification2.setName("name");
|
||||
classification2.setDescription("desc");
|
||||
classificationService.createClassification(classification2);
|
||||
all++;
|
||||
Classification classification3 = this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
classification3.setName("name1");
|
||||
classification3.setDescription("description");
|
||||
classificationService.createClassification(classification3);
|
||||
all++;
|
||||
|
||||
List<ClassificationSummary> list = classificationService.createClassificationQuery().nameIn("name").list();
|
||||
Assert.assertEquals(1, list.size());
|
||||
list = classificationService.createClassificationQuery().serviceLevelIn("P1D").descriptionLike("desc").list();
|
||||
Assert.assertEquals(2, list.size());
|
||||
list = classificationService.createClassificationQuery().serviceLevelIn("P2D").nameIn("name").list();
|
||||
Assert.assertEquals(0, list.size());
|
||||
list = classificationService.createClassificationQuery().descriptionLike("desc%").list();
|
||||
Assert.assertEquals(all, list.size());
|
||||
connection.commit();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDefaultSettingsWithClassificationQuery() throws NotAuthorizedException, SQLException,
|
||||
ClassificationAlreadyExistException, ClassificationNotFoundException, InvalidArgumentException,
|
||||
|
|
|
|||
Loading…
Reference in New Issue