TSK-559: Improved test coverage for the workbasket mapper

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

@@ -57,6 +57,7 @@ public class CreateWorkbasketAccTest extends AbstractAccTest {
         Workbasket createdWorkbasket = workbasketService.getWorkbasket("NT1234", "DOMAIN_A");
         assertNotNull(createdWorkbasket);
         assertNotNull(createdWorkbasket.getId());
+        assertEquals(workbasket, createdWorkbasket);
         Workbasket createdWorkbasket2 = workbasketService.getWorkbasket(createdWorkbasket.getId());
         assertNotNull(createdWorkbasket);
         assertEquals(createdWorkbasket, createdWorkbasket2);

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

@@ -1,8 +1,11 @@
 package acceptance.workbasket;
 
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
@@ -10,6 +13,7 @@ import acceptance.AbstractAccTest;
 import pro.taskana.Workbasket;
 import pro.taskana.WorkbasketPermission;
 import pro.taskana.WorkbasketService;
+import pro.taskana.WorkbasketSummary;
 import pro.taskana.WorkbasketType;
 import pro.taskana.exceptions.NotAuthorizedException;
 import pro.taskana.exceptions.WorkbasketNotFoundException;
@@ -30,19 +34,51 @@ public class GetWorkbasketAccTest extends AbstractAccTest {
         userName = "user_1_1",
         groupNames = {"group_1"})
     @Test
-    public void testGetWorkbasket()
+    public void testGetWorkbasketById()
         throws NotAuthorizedException, WorkbasketNotFoundException {
         WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
 
         Workbasket workbasket = workbasketService.getWorkbasket("WBI:100000000000000000000000000000000007");
 
-        Assert.assertEquals("DOMAIN_A", workbasket.getDomain());
+        assertEquals("DOMAIN_A", workbasket.getDomain());
-        Assert.assertEquals("PPK User 2 KSC 1", workbasket.getDescription());
+        assertEquals("PPK User 2 KSC 1", workbasket.getDescription());
-        Assert.assertEquals("PPK User 2 KSC 1", workbasket.getName());
+        assertEquals("PPK User 2 KSC 1", workbasket.getName());
-        Assert.assertEquals("USER_1_2", workbasket.getKey());
+        assertEquals("USER_1_2", workbasket.getKey());
-        Assert.assertEquals(WorkbasketType.PERSONAL, workbasket.getType());
+        assertEquals(WorkbasketType.PERSONAL, workbasket.getType());
-        Assert.assertEquals("Peter Maier", workbasket.getOwner());
+        assertEquals("Peter Maier", workbasket.getOwner());
-        Assert.assertEquals("Versicherung", workbasket.getOrgLevel1());
+        assertEquals("Versicherung", workbasket.getOrgLevel1());
+        assertEquals("Abteilung", workbasket.getOrgLevel2());
+        assertEquals("Projekt", workbasket.getOrgLevel3());
+        assertEquals("Team", workbasket.getOrgLevel4());
+        assertEquals("Custom1", workbasket.getCustom1());
+        assertEquals("Custom2", workbasket.getCustom2());
+        assertEquals("Custom3", workbasket.getCustom3());
+        assertEquals("Custom4", workbasket.getCustom4());
+    }
+
+    @WithAccessId(
+            userName = "user_1_1",
+            groupNames = {"group_1"})
+    @Test
+    public void testGetWorkbasketByKeyAndDomain()
+        throws NotAuthorizedException, WorkbasketNotFoundException {
+        WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+
+        Workbasket workbasket = workbasketService.getWorkbasket("USER_1_2", "DOMAIN_A");
+
+        assertEquals("WBI:100000000000000000000000000000000007", workbasket.getId());
+        assertEquals("PPK User 2 KSC 1", workbasket.getDescription());
+        assertEquals("PPK User 2 KSC 1", workbasket.getName());
+        assertEquals(WorkbasketType.PERSONAL, workbasket.getType());
+        assertEquals("Peter Maier", workbasket.getOwner());
+        assertEquals("Versicherung", workbasket.getOrgLevel1());
+        assertEquals("Abteilung", workbasket.getOrgLevel2());
+        assertEquals("Projekt", workbasket.getOrgLevel3());
+        assertEquals("Team", workbasket.getOrgLevel4());
+        assertEquals("Custom1", workbasket.getCustom1());
+        assertEquals("Custom2", workbasket.getCustom2());
+        assertEquals("Custom3", workbasket.getCustom3());
+        assertEquals("Custom4", workbasket.getCustom4());
     }
 
     @WithAccessId(
@@ -54,11 +90,62 @@ public class GetWorkbasketAccTest extends AbstractAccTest {
         List<WorkbasketPermission> permissions = workbasketService
             .getPermissionsForWorkbasket("WBI:100000000000000000000000000000000007");
 
-        Assert.assertEquals(4, permissions.size());
+        assertEquals(4, permissions.size());
-        Assert.assertTrue(permissions.contains(WorkbasketPermission.READ));
+        assertTrue(permissions.contains(WorkbasketPermission.READ));
-        Assert.assertTrue(permissions.contains(WorkbasketPermission.OPEN));
+        assertTrue(permissions.contains(WorkbasketPermission.OPEN));
-        Assert.assertTrue(permissions.contains(WorkbasketPermission.TRANSFER));
+        assertTrue(permissions.contains(WorkbasketPermission.TRANSFER));
-        Assert.assertTrue(permissions.contains(WorkbasketPermission.APPEND));
+        assertTrue(permissions.contains(WorkbasketPermission.APPEND));
+    }
+
+    @WithAccessId(
+        userName = "user_1_1",
+        groupNames = {"group_1"})
+    @Test
+    public void testGetWorkbasketAsSummary()
+        throws NotAuthorizedException, WorkbasketNotFoundException {
+        WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+
+        WorkbasketSummary workbasketSummary = workbasketService.getWorkbasket("WBI:100000000000000000000000000000000007").asSummary();
+
+        assertEquals("DOMAIN_A", workbasketSummary.getDomain());
+        assertEquals("PPK User 2 KSC 1", workbasketSummary.getDescription());
+        assertEquals("PPK User 2 KSC 1", workbasketSummary.getName());
+        assertEquals("USER_1_2", workbasketSummary.getKey());
+        assertEquals(WorkbasketType.PERSONAL, workbasketSummary.getType());
+        assertEquals("Peter Maier", workbasketSummary.getOwner());
+        assertEquals("Versicherung", workbasketSummary.getOrgLevel1());
+        assertEquals("Abteilung", workbasketSummary.getOrgLevel2());
+        assertEquals("Projekt", workbasketSummary.getOrgLevel3());
+        assertEquals("Team", workbasketSummary.getOrgLevel4());
+    }
+
+    @WithAccessId(
+        userName = "user_1_1",
+        groupNames = {"group_1"})
+    @Test
+    public void testGetWorkbasketsByPermissions()
+        throws NotAuthorizedException, WorkbasketNotFoundException {
+
+        WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+        List<WorkbasketPermission> permissions = new ArrayList<WorkbasketPermission>();
+        permissions.add(WorkbasketPermission.READ);
+        permissions.add(WorkbasketPermission.OPEN);
+        permissions.add(WorkbasketPermission.APPEND);
+        permissions.add(WorkbasketPermission.TRANSFER);
+
+        List<WorkbasketSummary> workbasketSummaries = workbasketService.getWorkbaskets(permissions);
+
+        List<WorkbasketSummary> expectedSummaries = new ArrayList<WorkbasketSummary>();
+        expectedSummaries.add(workbasketService.getWorkbasket("WBI:100000000000000000000000000000000002").asSummary());
+        expectedSummaries.add(workbasketService.getWorkbasket("WBI:100000000000000000000000000000000004").asSummary());
+        expectedSummaries.add(workbasketService.getWorkbasket("WBI:100000000000000000000000000000000006").asSummary());
+        expectedSummaries.add(workbasketService.getWorkbasket("WBI:100000000000000000000000000000000007").asSummary());
+
+        assertEquals(4, workbasketSummaries.size());
+
+        for (WorkbasketSummary wbSummary : workbasketSummaries) {
+            assertTrue(expectedSummaries.contains(wbSummary));
+        }
     }
 
     @Test(expected = WorkbasketNotFoundException.class)
@@ -68,6 +155,13 @@ public class GetWorkbasketAccTest extends AbstractAccTest {
         workbasketService.getWorkbasket("INVALID_ID");
     }
 
+    @Test(expected = WorkbasketNotFoundException.class)
+    public void testThrowsExceptionIfKeyOrDomainIsInvalid()
+            throws NotAuthorizedException, WorkbasketNotFoundException {
+        WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+        workbasketService.getWorkbasket("INVALID_KEY", "INVALID_DOMAIN");
+    }
+
     @Test(expected = NotAuthorizedException.class)
     public void testThrowsExceptionIfNotAuthorized()
         throws NotAuthorizedException, WorkbasketNotFoundException {

lib/taskana-core/src/test/java/acceptance/workbasket/UpdateWorkbasketAuthorizationsAccTest.java

@@ -6,10 +6,11 @@ import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import static org.junit.Assert.assertEquals;
 
+import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
@@ -68,12 +69,12 @@ public class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
             .findFirst()
             .orElse(null);
 
-        Assert.assertEquals("Rojas, Miguel", updatedItem.getAccessName());
+        assertEquals("Rojas, Miguel", updatedItem.getAccessName());
-        Assert.assertEquals(false, updatedItem.isPermAppend());
+        assertEquals(false, updatedItem.isPermAppend());
-        Assert.assertEquals(true, updatedItem.isPermRead());
+        assertEquals(true, updatedItem.isPermRead());
-        Assert.assertEquals(true, updatedItem.isPermCustom11());
+        assertEquals(true, updatedItem.isPermCustom11());
-        Assert.assertEquals(true, updatedItem.isPermCustom1());
+        assertEquals(true, updatedItem.isPermCustom1());
-        Assert.assertEquals(false, updatedItem.isPermCustom2());
+        assertEquals(false, updatedItem.isPermCustom2());
     }
 
     @WithAccessId(
@@ -102,11 +103,11 @@ public class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
 
         ((WorkbasketAccessItemImpl) accessItem).setAccessId("user1");
         accessItem = workbasketService.updateWorkbasketAccessItem(accessItem);
-        Assert.assertEquals(false, accessItem.isPermAppend());
+        assertEquals(false, accessItem.isPermAppend());
-        Assert.assertEquals(true, accessItem.isPermRead());
+        assertEquals(true, accessItem.isPermRead());
-        Assert.assertEquals(true, accessItem.isPermCustom11());
+        assertEquals(true, accessItem.isPermCustom11());
-        Assert.assertEquals(true, accessItem.isPermCustom1());
+        assertEquals(true, accessItem.isPermCustom1());
-        Assert.assertEquals(false, accessItem.isPermCustom2());
+        assertEquals(false, accessItem.isPermCustom2());
 
         ((WorkbasketAccessItemImpl) accessItem).setWorkbasketId("2");
         try {
@@ -138,7 +139,7 @@ public class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
         List<TaskSummary> tasks = taskService.createTaskQuery()
             .workbasketKeyDomainIn(new KeyDomain(wbKey, wbDomain))
             .list();
-        Assert.assertEquals(1, tasks.size());
+        assertEquals(1, tasks.size());
         assertThat(createdTask, not(equalTo(null)));
 
         List<WorkbasketAccessItem> accessItems = workbasketService
@@ -148,7 +149,7 @@ public class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
             .findFirst()
             .orElse(null);
 
-        Assert.assertTrue(theAccessItem != null);
+        assertTrue(theAccessItem != null);
         theAccessItem.setPermOpen(false);
         workbasketService.updateWorkbasketAccessItem(theAccessItem);
 
@@ -242,6 +243,31 @@ public class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
         assertFalse(item0.isPermTransfer());
     }
 
+    @WithAccessId(
+            userName = "teamlead_1",
+            groupNames = {"group_1", "businessadmin"})
+    @Test
+    public void testDeleteAccessItem() throws NotAuthorizedException, InvalidArgumentException {
+        WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+        final String wbId = "WBI:100000000000000000000000000000000001";
+
+        List<WorkbasketAccessItem> originalList = workbasketService.getWorkbasketAccessItems(wbId);
+
+        List<WorkbasketAccessItem> accessList = new ArrayList<WorkbasketAccessItem>(originalList);
+        WorkbasketAccessItem newItem = workbasketService.newWorkbasketAccessItem(wbId, "group_1");
+        accessList.add(newItem);
+        int countBefore = workbasketService.getWorkbasketAccessItems(wbId).size();
+        workbasketService.setWorkbasketAccessItems(wbId, accessList);
+        int countAfter = workbasketService.getWorkbasketAccessItems(wbId).size();
+        assertEquals(countBefore + 1, countAfter);
+
+        workbasketService.setWorkbasketAccessItems(wbId, accessList);
+        String newId = workbasketService.getWorkbasketAccessItems(wbId).get(countAfter - 1).getId();
+        workbasketService.deleteWorkbasketAccessItem(newId);
+
+        assertEquals(originalList.toString(), workbasketService.getWorkbasketAccessItems(wbId).toString());
+    }
+
     @WithAccessId(
         userName = "teamlead_1",
         groupNames = {"businessadmin"})

lib/taskana-core/src/test/resources/sql/workbasket.sql

@@ -5,7 +5,7 @@ INSERT INTO TASKANA.WORKBASKET VALUES ('WBI:100000000000000000000000000000000003
 INSERT INTO TASKANA.WORKBASKET VALUES ('WBI:100000000000000000000000000000000004', 'TEAMLEAD_1', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'PPK Teamlead KSC 1', 'DOMAIN_A', 'PERSONAL', 'PPK Teamlead KSC 1', '', '', '', '', '', '', '', '', '');
 INSERT INTO TASKANA.WORKBASKET VALUES ('WBI:100000000000000000000000000000000005', 'TEAMLEAD_2', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'PPK Teamlead KSC 2', 'DOMAIN_A', 'PERSONAL', 'PPK Teamlead KSC 2', '', '', '', '', '', '', '', '', '');
 INSERT INTO TASKANA.WORKBASKET VALUES ('WBI:100000000000000000000000000000000006', 'USER_1_1', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'PPK User 1 KSC 1', 'DOMAIN_A', 'PERSONAL', 'PPK User 1 KSC 1', '', '', '', '', '', '', '', '', '');
-INSERT INTO TASKANA.WORKBASKET VALUES ('WBI:100000000000000000000000000000000007', 'USER_1_2', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'PPK User 2 KSC 1', 'DOMAIN_A', 'PERSONAL', 'PPK User 2 KSC 1', 'Peter Maier', '', '', '', '', 'Versicherung', '', '', '');
+INSERT INTO TASKANA.WORKBASKET VALUES ('WBI:100000000000000000000000000000000007', 'USER_1_2', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'PPK User 2 KSC 1', 'DOMAIN_A', 'PERSONAL', 'PPK User 2 KSC 1', 'Peter Maier', 'Custom1', 'Custom2', 'Custom3', 'Custom4', 'Versicherung', 'Abteilung', 'Projekt', 'Team');
 INSERT INTO TASKANA.WORKBASKET VALUES ('WBI:100000000000000000000000000000000008', 'USER_2_1', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'PPK User 1 KSC 2', 'DOMAIN_A', 'PERSONAL', 'PPK User 1 KSC 2', '', '', '', '', '', '', '', '', '');
 INSERT INTO TASKANA.WORKBASKET VALUES ('WBI:100000000000000000000000000000000009', 'USER_2_2', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'PPK User 2 KSC 2', 'DOMAIN_A', 'PERSONAL', 'PPK User 2 KSC 2', '', '', '', '', '', '', '', '', '');
 INSERT INTO TASKANA.WORKBASKET VALUES ('WBI:100000000000000000000000000000000010', 'TPK_VIP', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'Themenpostkorb VIP', 'DOMAIN_A', 'TOPIC', 'Themenpostkorb VIP', '', '', '', '', '', '', '', '', '');