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

TSK-816: Deleted duplicated tests and moved functionality tests into acceptance

This commit is contained in:
julian.schallenmueller 2019-03-25 16:23:13 +01:00 committed by Holger Hagen
parent 4a7664f9ef
commit 1fc1c92c75
5 changed files with 89 additions and 362 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -217,6 +217,10 @@ public class WorkbasketImpl implements Workbasket {
result.setOwner(this.getOwner());
result.setDomain(this.getDomain());
result.setType(this.getType());
result.setCustom1(this.getCustom1());
result.setCustom2(this.getCustom2());
result.setCustom3(this.getCustom3());
result.setCustom4(this.getCustom4());
result.setOrgLevel1(this.getOrgLevel1());
result.setOrgLevel2(this.getOrgLevel2());
result.setOrgLevel3(this.getOrgLevel3());
@ -238,6 +242,7 @@ public class WorkbasketImpl implements Workbasket {
result = prime * result + ((domain == null) ? 0 : domain.hashCode());
result = prime * result + ((id == null) ? 0 : id.hashCode());
result = prime * result + ((key == null) ? 0 : key.hashCode());
result = prime * result + (markedForDeletion ? 1231 : 1237);
result = prime * result + ((modified == null) ? 0 : modified.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((orgLevel1 == null) ? 0 : orgLevel1.hashCode());
@ -324,6 +329,9 @@ public class WorkbasketImpl implements Workbasket {
} else if (!key.equals(other.key)) {
return false;
}
if (markedForDeletion != other.markedForDeletion) {
return false;
}
if (modified == null) {
if (other.modified != null) {
return false;

36
lib/taskana-core/src/main/java/pro/taskana/impl/WorkbasketSummaryImpl.java
View File

@ -236,10 +236,15 @@ public class WorkbasketSummaryImpl implements WorkbasketSummary {
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((custom1 == null) ? 0 : custom1.hashCode());
result = prime * result + ((custom2 == null) ? 0 : custom2.hashCode());
result = prime * result + ((custom3 == null) ? 0 : custom3.hashCode());
result = prime * result + ((custom4 == null) ? 0 : custom4.hashCode());
result = prime * result + ((description == null) ? 0 : description.hashCode());
result = prime * result + ((domain == null) ? 0 : domain.hashCode());
result = prime * result + ((id == null) ? 0 : id.hashCode());
result = prime * result + ((key == null) ? 0 : key.hashCode());
result = prime * result + (markedForDeletion ? 1231 : 1237);
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((orgLevel1 == null) ? 0 : orgLevel1.hashCode());
result = prime * result + ((orgLevel2 == null) ? 0 : orgLevel2.hashCode());
@ -262,6 +267,34 @@ public class WorkbasketSummaryImpl implements WorkbasketSummary {
return false;
}
WorkbasketSummaryImpl other = (WorkbasketSummaryImpl) obj;
if (custom1 == null) {
if (other.custom1 != null) {
return false;
}
} else if (!custom1.equals(other.custom1)) {
return false;
}
if (custom2 == null) {
if (other.custom2 != null) {
return false;
}
} else if (!custom2.equals(other.custom2)) {
return false;
}
if (custom3 == null) {
if (other.custom3 != null) {
return false;
}
} else if (!custom3.equals(other.custom3)) {
return false;
}
if (custom4 == null) {
if (other.custom4 != null) {
return false;
}
} else if (!custom4.equals(other.custom4)) {
return false;
}
if (description == null) {
if (other.description != null) {
return false;
@ -290,6 +323,9 @@ public class WorkbasketSummaryImpl implements WorkbasketSummary {
} else if (!key.equals(other.key)) {
return false;
}
if (markedForDeletion != other.markedForDeletion) {
return false;
}
if (name == null) {
if (other.name != null) {
return false;

22
lib/taskana-core/src/test/java/acceptance/workbasket/CreateWorkbasketAccTest.java
View File

@ -2,6 +2,7 @@ package acceptance.workbasket;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.util.List;
@ -57,6 +58,7 @@ public class CreateWorkbasketAccTest extends AbstractAccTest {
Workbasket createdWorkbasket = workbasketService.getWorkbasket("NT1234", "DOMAIN_A");
assertNotNull(createdWorkbasket);
assertNotNull(createdWorkbasket.getId());
assertTrue(createdWorkbasket.getId().startsWith("WBI"));
assertEquals(workbasket, createdWorkbasket);
Workbasket createdWorkbasket2 = workbasketService.getWorkbasket(createdWorkbasket.getId());
assertNotNull(createdWorkbasket);
@ -144,6 +146,26 @@ public class CreateWorkbasketAccTest extends AbstractAccTest {
fail("InvalidWorkbasketException was expected");
} catch (InvalidWorkbasketException e) {
}
workbasket = workbasketService.newWorkbasket("", "novatec");
workbasket.setName("Megabasket");
workbasket.setType(WorkbasketType.GROUP);
workbasket.setOrgLevel1("company");
try { // empty key
workbasketService.createWorkbasket(workbasket);
fail("InvalidWorkbasketException was expected");
} catch (InvalidWorkbasketException e) {
}
workbasket = workbasketService.newWorkbasket("key", "novatec");
workbasket.setName("");
workbasket.setType(WorkbasketType.GROUP);
workbasket.setOrgLevel1("company");
try { // empty name
workbasketService.createWorkbasket(workbasket);
fail("InvalidWorkbasketException was expected");
} catch (InvalidWorkbasketException e) {
}
}
@WithAccessId(

24
lib/taskana-core/src/test/java/acceptance/workbasket/GetWorkbasketAccTest.java
View File

@ -129,6 +129,11 @@ public class GetWorkbasketAccTest extends AbstractAccTest {
assertEquals("abteilung", workbasketSummary.getOrgLevel2());
assertEquals("projekt", workbasketSummary.getOrgLevel3());
assertEquals("team", workbasketSummary.getOrgLevel4());
assertEquals("custom1", workbasketSummary.getCustom1());
assertEquals("custom2", workbasketSummary.getCustom2());
assertEquals("custom3", workbasketSummary.getCustom3());
assertEquals("custom4", workbasketSummary.getCustom4());
assertEquals(false, workbasketSummary.isMarkedForDeletion());
}
@Test(expected = WorkbasketNotFoundException.class)
@ -146,10 +151,27 @@ public class GetWorkbasketAccTest extends AbstractAccTest {
}
@Test(expected = NotAuthorizedException.class)
public void testThrowsExceptionIfNotAuthorized()
public void testGetByIdNotAuthorized()
throws NotAuthorizedException, WorkbasketNotFoundException {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
workbasketService.getWorkbasket("WBI:100000000000000000000000000000000001");
}
@Test(expected = NotAuthorizedException.class)
public void testGetByKeyDomainNotAuthorized()
throws NotAuthorizedException, WorkbasketNotFoundException {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
workbasketService.getWorkbasket("GPK_KSC", "DOMAIN_A");
}
@WithAccessId(
userName = "user_1_1",
groupNames = {"group_1"})
@Test(expected = WorkbasketNotFoundException.class)
public void testGetWorkbasketByIdNotExisting()
throws NotAuthorizedException, WorkbasketNotFoundException {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
workbasketService.getWorkbasket("NOT EXISTING ID");
}
}

361
lib/taskana-core/src/test/java/pro/taskana/impl/WorkbasketServiceImplTest.java
View File

@ -4,7 +4,6 @@ import static org.hamcrest.core.IsEqual.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 static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
@ -32,7 +31,6 @@ import pro.taskana.TaskQuery;
import pro.taskana.TaskService;
import pro.taskana.TaskSummary;
import pro.taskana.Workbasket;
import pro.taskana.WorkbasketPermission;
import pro.taskana.WorkbasketType;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.exceptions.DomainNotFoundException;
@ -91,291 +89,6 @@ public class WorkbasketServiceImplTest {
MockitoAnnotations.initMocks(this);
}
@Test(expected = NotAuthorizedException.class)
public void testGetWorkbasketById_NonAuthorizedUser()
throws WorkbasketNotFoundException, NotAuthorizedException {
String wbId = "ID-1";
Workbasket wb = createTestWorkbasket(wbId, "Key-1");
WorkbasketPermission authorization = WorkbasketPermission.READ;
doReturn(wb).when(workbasketMapperMock).findById(wbId);
doThrow(NotAuthorizedException.class).when(cutSpy).checkAuthorization(wb.getId(),
authorization);
try {
cutSpy.getWorkbasket(wbId);
} catch (NotAuthorizedException ex) {
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(workbasketMapperMock, times(1)).findById(wbId);
verify(cutSpy, times(1)).checkAuthorization(wb.getId(), authorization);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verify(taskanaEngineImplMock, times(1)).isUserInRole(any());
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
taskanaEngineImplMock, taskanaEngineConfigurationMock);
throw ex;
}
}
@Test(expected = WorkbasketNotFoundException.class)
public void testGetWorkbasketById_AuthenticatedWithoutResult()
throws NotAuthorizedException, WorkbasketNotFoundException {
String wbId = "ID-1";
doReturn(null).when(workbasketMapperMock).findById(wbId);
try {
cutSpy.getWorkbasket(wbId);
} catch (WorkbasketNotFoundException ex) {
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(workbasketMapperMock, times(1)).findById(wbId);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
taskanaEngineImplMock, taskanaEngineConfigurationMock);
throw ex;
}
}
@Test
public void testGetWorkbasketById() throws NotAuthorizedException, WorkbasketNotFoundException {
String wbId = "ID-1";
Workbasket wb = createTestWorkbasket(wbId, "key-1");
WorkbasketPermission authorization = WorkbasketPermission.READ;
doReturn(wb).when(workbasketMapperMock).findById(wbId);
doNothing().when(cutSpy).checkAuthorization(wb.getId(), authorization);
Workbasket actualWb = cutSpy.getWorkbasket(wbId);
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(workbasketMapperMock, times(1)).findById(wbId);
verify(cutSpy, times(1)).checkAuthorization(wb.getId(), authorization);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verify(taskanaEngineImplMock, times(1)).isUserInRole(any());
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
taskanaEngineImplMock, taskanaEngineConfigurationMock);
assertThat(actualWb, equalTo(wb));
}
@Test(expected = NotAuthorizedException.class)
public void testGetWorkbasketByKey_NonAuthorizedUser()
throws WorkbasketNotFoundException, NotAuthorizedException {
String wbKey = "Key-1";
Workbasket wb = createTestWorkbasket("ID", wbKey);
WorkbasketPermission authorization = WorkbasketPermission.READ;
doReturn(wb).when(workbasketMapperMock).findByKeyAndDomain(wbKey, "domain");
doThrow(NotAuthorizedException.class).when(cutSpy).checkAuthorization(wbKey, "domain", authorization);
try {
cutSpy.getWorkbasket(wbKey, "domain");
} catch (NotAuthorizedException ex) {
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(workbasketMapperMock, times(1)).findByKeyAndDomain(wbKey, "domain");
verify(cutSpy, times(1)).checkAuthorization(wbKey, "domain", authorization);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verify(taskanaEngineImplMock, times(1)).isUserInRole(any());
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
taskanaEngineImplMock, taskanaEngineConfigurationMock);
throw ex;
}
}
@Test(expected = WorkbasketNotFoundException.class)
public void testGetWorkbasketByKey_AuthenticatedWithoutResult()
throws NotAuthorizedException, WorkbasketNotFoundException {
String wbKey = "Key-1";
doReturn(null).when(workbasketMapperMock).findByKeyAndDomain(wbKey, "dummy");
try {
cutSpy.getWorkbasket(wbKey, "dummy");
} catch (WorkbasketNotFoundException ex) {
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(workbasketMapperMock, times(1)).findByKeyAndDomain(wbKey, "dummy");
verify(taskanaEngineImplMock, times(1)).returnConnection();
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
taskanaEngineImplMock, taskanaEngineConfigurationMock);
throw ex;
}
}
@Test
public void testGetWorkbasketByKey() throws NotAuthorizedException, WorkbasketNotFoundException {
String wbKey = "Key-1";
Workbasket wb = createTestWorkbasket("ID-1", wbKey);
WorkbasketPermission authorization = WorkbasketPermission.READ;
doNothing().when(cutSpy).checkAuthorization(wbKey, "test", authorization);
doReturn(wb).when(workbasketMapperMock).findByKeyAndDomain(wbKey, "test");
Workbasket actualWb = cutSpy.getWorkbasket(wbKey, "test");
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(cutSpy, times(1)).checkAuthorization(wbKey, "test", authorization);
verify(workbasketMapperMock, times(1)).findByKeyAndDomain(wbKey, "test");
verify(taskanaEngineImplMock, times(1)).returnConnection();
verify(taskanaEngineImplMock, times(1)).isUserInRole(any());
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
taskanaEngineImplMock, taskanaEngineConfigurationMock);
assertThat(actualWb, equalTo(wb));
}
@Test
public void testCreateWorkbasket_InvalidWorkbasketCases()
throws NotAuthorizedException, WorkbasketAlreadyExistException,
DomainNotFoundException {
WorkbasketImpl wb = new WorkbasketImpl();
int serviceCalls = 1;
// KEY NULL
try {
wb.setId(null);
wb.setKey(null);
doReturn(null).when(workbasketMapperMock).findByKeyAndDomain(any(), any());
cutSpy.createWorkbasket(wb);
} catch (InvalidWorkbasketException ex) {
verify(taskanaEngineImplMock, times(serviceCalls)).openConnection();
verify(taskanaEngineImplMock, times(serviceCalls)).returnConnection();
verify(taskanaEngineImplMock, times(serviceCalls)).checkRoleMembership(any());
verify(workbasketMapperMock, times(serviceCalls)).findByKeyAndDomain(any(), any());
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
taskanaEngineImplMock, taskanaEngineConfigurationMock);
assertThat(wb.getId(), not(equalTo(null)));
assertThat(wb.getCreated(), not(equalTo(null)));
assertThat(wb.getModified(), not(equalTo(null)));
}
// KEY EMPTY
serviceCalls++;
try {
wb.setKey("");
cutSpy.createWorkbasket(wb);
} catch (InvalidWorkbasketException ex) {
verify(taskanaEngineImplMock, times(serviceCalls)).openConnection();
verify(taskanaEngineImplMock, times(serviceCalls)).returnConnection();
verify(taskanaEngineImplMock, times(serviceCalls)).checkRoleMembership(any());
verify(workbasketMapperMock, times(serviceCalls)).findByKeyAndDomain(any(), any());
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
taskanaEngineImplMock, taskanaEngineConfigurationMock);
assertThat(wb.getId(), not(equalTo(null)));
assertThat(wb.getCreated(), not(equalTo(null)));
assertThat(wb.getModified(), not(equalTo(null)));
}
// NAME NULL
serviceCalls++;
try {
wb.setKey("KEY");
wb.setName(null);
cutSpy.createWorkbasket(wb);
} catch (InvalidWorkbasketException ex) {
verify(taskanaEngineImplMock, times(serviceCalls)).openConnection();
verify(taskanaEngineImplMock, times(serviceCalls)).returnConnection();
verify(taskanaEngineImplMock, times(serviceCalls)).checkRoleMembership(any());
verify(workbasketMapperMock, times(serviceCalls)).findByKeyAndDomain(any(), any());
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
taskanaEngineImplMock, taskanaEngineConfigurationMock);
assertThat(wb.getId(), not(equalTo(null)));
assertThat(wb.getCreated(), not(equalTo(null)));
assertThat(wb.getModified(), not(equalTo(null)));
}
// NAME EMPTY
serviceCalls++;
try {
wb.setName("");
cutSpy.createWorkbasket(wb);
} catch (InvalidWorkbasketException ex) {
verify(taskanaEngineImplMock, times(serviceCalls)).openConnection();
verify(taskanaEngineImplMock, times(serviceCalls)).returnConnection();
verify(taskanaEngineImplMock, times(serviceCalls)).checkRoleMembership(any());
verify(workbasketMapperMock, times(serviceCalls)).findByKeyAndDomain(any(), any());
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
taskanaEngineImplMock, taskanaEngineConfigurationMock);
assertThat(wb.getId(), not(equalTo(null)));
assertThat(wb.getCreated(), not(equalTo(null)));
assertThat(wb.getModified(), not(equalTo(null)));
}
// DOMAIN NULL
serviceCalls++;
try {
wb.setName("Name");
wb.setDomain(null);
cutSpy.createWorkbasket(wb);
} catch (InvalidWorkbasketException ex) {
verify(taskanaEngineImplMock, times(serviceCalls)).openConnection();
verify(taskanaEngineImplMock, times(serviceCalls)).returnConnection();
verify(taskanaEngineImplMock, times(serviceCalls)).checkRoleMembership(any());
verify(workbasketMapperMock, times(serviceCalls)).findByKeyAndDomain(any(), any());
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
taskanaEngineImplMock, taskanaEngineConfigurationMock);
assertThat(wb.getId(), not(equalTo(null)));
assertThat(wb.getCreated(), not(equalTo(null)));
assertThat(wb.getModified(), not(equalTo(null)));
}
// TYPE NULL
serviceCalls++;
try {
wb.setDomain("Domain");
wb.setType(null);
cutSpy.createWorkbasket(wb);
} catch (InvalidWorkbasketException ex) {
verify(taskanaEngineImplMock, times(serviceCalls)).openConnection();
verify(taskanaEngineImplMock, times(serviceCalls)).returnConnection();
verify(taskanaEngineImplMock, times(serviceCalls)).checkRoleMembership(any());
verify(workbasketMapperMock, times(serviceCalls)).findByKeyAndDomain(any(), any());
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
taskanaEngineImplMock, taskanaEngineConfigurationMock);
assertThat(wb.getId(), not(equalTo(null)));
assertThat(wb.getCreated(), not(equalTo(null)));
assertThat(wb.getModified(), not(equalTo(null)));
}
}
@Test
public void testCreateWorkbasket_WithoutDistibutionTargets()
throws WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException,
WorkbasketAlreadyExistException, DomainNotFoundException {
WorkbasketImpl expectedWb = createTestWorkbasket(null, "Key-1");
doNothing().when(workbasketMapperMock).insert(expectedWb);
doReturn(expectedWb).when(workbasketMapperMock).findById(any());
doReturn(taskanaEngineConfigurationMock).when(taskanaEngineImplMock).getConfiguration();
doReturn(false).when(taskanaEngineConfigurationMock).isSecurityEnabled();
doReturn(true).when(taskanaEngineImplMock).domainExists(any());
Workbasket actualWb = cutSpy.createWorkbasket(expectedWb);
cutSpy.setDistributionTargets(expectedWb.getId(), null);
verify(taskanaEngineImplMock, times(4)).openConnection();
verify(taskanaEngineImplMock, times(1)).getConfiguration();
verify(taskanaEngineConfigurationMock, times(1)).isSecurityEnabled();
verify(workbasketMapperMock, times(1)).insert(expectedWb);
verify(workbasketMapperMock, times(1)).findByKeyAndDomain(any(), any());
verify(workbasketMapperMock, times(2)).findById(expectedWb.getId());
verify(workbasketMapperMock, times(1)).update(any());
verify(taskanaEngineImplMock, times(4)).returnConnection();
verify(taskanaEngineImplMock, times(2)).checkRoleMembership(any());
verify(taskanaEngineImplMock, times(1)).isUserInRole(any());
verify(taskanaEngineImplMock, times(1)).domainExists(any());
verify(distributionTargetMapperMock, times(1)).deleteAllDistributionTargetsBySourceId(any());
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
taskanaEngineImplMock, taskanaEngineConfigurationMock);
assertThat(actualWb.getId(), not(equalTo(null)));
assertThat(actualWb.getId(), startsWith("WBI"));
assertThat(actualWb.getCreated(), not(equalTo(null)));
assertThat(actualWb.getModified(), not(equalTo(null)));
}
@Test
public void testCreateWorkbasket_WithDistibutionTargets()
throws WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException,
@ -462,55 +175,6 @@ public class WorkbasketServiceImplTest {
}
}
@Test
public void testDeleteWorkbasketWithNullOrEmptyParam()
throws WorkbasketNotFoundException, NotAuthorizedException, WorkbasketInUseException {
// null param
try {
cutSpy.deleteWorkbasket(null);
fail("delete() should have thrown an InvalidArgumentException, when the param ID is null.");
} catch (InvalidArgumentException e) {
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(taskanaEngineImplMock, times(1)).returnConnection();
verify(taskanaEngineImplMock, times(1)).checkRoleMembership(any());
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
taskanaEngineImplMock, taskanaEngineConfigurationMock);
}
// null param
try {
cutSpy.deleteWorkbasket("");
fail("delete() should have thrown an InvalidArgumentException, when the param ID is EMPTY-String.");
} catch (InvalidArgumentException e) {
verify(taskanaEngineImplMock, times(2)).openConnection();
verify(taskanaEngineImplMock, times(2)).returnConnection();
verify(taskanaEngineImplMock, times(2)).checkRoleMembership(any());
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
taskanaEngineImplMock, taskanaEngineConfigurationMock);
}
}
@Test(expected = WorkbasketNotFoundException.class)
public void testDeleteWorkbasketNotExisting()
throws WorkbasketNotFoundException, NotAuthorizedException, WorkbasketInUseException, InvalidArgumentException {
String workbasketId = "WBI:0";
doThrow(WorkbasketNotFoundException.class).when(cutSpy).getWorkbasket(workbasketId);
try {
cutSpy.deleteWorkbasket(workbasketId);
} catch (WorkbasketNotFoundException e) {
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(cutSpy, times(1)).getWorkbasket(workbasketId);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verify(taskanaEngineImplMock, times(1)).checkRoleMembership(any());
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
taskanaEngineImplMock, taskanaEngineConfigurationMock);
throw e;
}
}
@Test(expected = WorkbasketNotFoundException.class)
public void testDeleteWorkbasketIsUsed()
throws NotAuthorizedException, WorkbasketInUseException, InvalidArgumentException, WorkbasketNotFoundException {
@ -533,31 +197,6 @@ public class WorkbasketServiceImplTest {
}
}
@Test
public void testDeleteWorkbasket()
throws NotAuthorizedException, WorkbasketInUseException, InvalidArgumentException, WorkbasketNotFoundException {
Workbasket wb = createTestWorkbasket("WBI:0", "wb-key");
try {
// WB deleted
cutSpy.deleteWorkbasket(wb.getId());
} catch (WorkbasketNotFoundException e) {
// Workbasket is deleted
}
verify(taskanaEngineImplMock, times(2)).openConnection();
verify(cutSpy, times(1)).getWorkbasket(wb.getId());
verify(taskanaEngineImplMock, times(0)).getSqlSession();
verify(sqlSessionMock, times(0)).getMapper(TaskMapper.class);
verify(workbasketMapperMock, times(1)).findById(wb.getId());
verify(taskanaEngineImplMock, times(2)).returnConnection();
verify(taskanaEngineImplMock, times(1)).checkRoleMembership(any());
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
taskanaEngineImplMock, taskanaEngineConfigurationMock);
}
private WorkbasketImpl createTestWorkbasket(String id, String key) {
WorkbasketImpl workbasket = new WorkbasketImpl();
workbasket.setId(id);