gms/src/test/java/it/inaf/ia2/gms/controller/MembersControllerTest.java

 package it.inaf.ia2.gms.controller;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
+import static it.inaf.ia2.gms.controller.ControllersMockData.getInafGroup;
+import static it.inaf.ia2.gms.controller.ControllersMockData.getLbtGroup;
 import it.inaf.ia2.gms.manager.MembershipManager;
 import it.inaf.ia2.gms.manager.PermissionsManager;
 import it.inaf.ia2.gms.model.request.AddMemberRequest;
 import it.inaf.ia2.gms.model.Permission;
+import it.inaf.ia2.gms.persistence.GroupsDAO;
 import it.inaf.ia2.gms.persistence.model.GroupEntity;
+import it.inaf.ia2.gms.persistence.model.MembershipEntity;
+import it.inaf.ia2.gms.service.GroupNameService;
 import it.inaf.ia2.gms.service.GroupsService;
+import java.util.ArrayList;
+import java.util.Optional;
 import static org.hamcrest.CoreMatchers.is;
 import org.junit.Before;
 import org.junit.Test;
@@ -22,6 +29,7 @@ import org.mockito.junit.MockitoJUnitRunner;
 import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.MockMvc;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@@ -39,6 +47,9 @@ public class MembersControllerTest {
     @Mock
     private MembershipManager membershipManager;
 
+    @Mock
+    private GroupsDAO groupsDAO;
+
     @InjectMocks
     private MembersController controller;
 
@@ -46,29 +57,31 @@ public class MembersControllerTest {
 
     private final ObjectMapper mapper = new ObjectMapper();
 
+    private GroupEntity lbt = getLbtGroup();
+    private GroupEntity inaf = getInafGroup();
+
     @Before
     public void init() {
+        controller.groupNameService = new GroupNameService(groupsDAO);
         mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
 
-        GroupEntity group = new GroupEntity();
-        group.setId("group_id");
-        group.setName("GroupName");
-        group.setPath("parent_id.group_id");
+        when(groupsService.getGroupById(eq("lbt_id"))).thenReturn(lbt);
 
-        when(groupsService.getGroupById(eq("group_id"))).thenReturn(group);
+        when(groupsDAO.findGroupByParentAndName("", "LBT")).thenReturn(Optional.of(lbt));
+        when(groupsDAO.findGroupByParentAndName("lbt_id", "INAF")).thenReturn(Optional.of(inaf));
     }
 
     @Test
-    public void testAddMember() throws Exception {
+    public void testAddMemberPaginated() throws Exception {
 
         AddMemberRequest request = new AddMemberRequest();
-        request.setGroupId("group_id");
+        request.setGroupId("lbt_id");
         request.setUserId("user_id");
         request.setPaginatorPage(1);
         request.setPaginatorPageSize(10);
         request.setPermission(Permission.VIEW_MEMBERS);
 
-        mockMvc.perform(post("/member")
+        mockMvc.perform(post("/ui/member")
                 .content(mapper.writeValueAsString(request))
                 .contentType(MediaType.APPLICATION_JSON_VALUE))
                 .andExpect(status().isCreated())
@@ -78,12 +91,54 @@ public class MembersControllerTest {
     }
 
     @Test
-    public void testRemoveMember() throws Exception {
+    public void testRemoveMemberPaginated() throws Exception {
 
-        mockMvc.perform(delete("/member?groupId=group_id&userId=user_id&paginatorPage=1&paginatorPageSize=10"))
+        mockMvc.perform(delete("/ui/member?groupId=group_id&userId=user_id&paginatorPage=1&paginatorPageSize=10"))
                 .andExpect(status().isOk())
                 .andExpect(jsonPath("$.currentPage", is(1)));
 
         verify(membershipManager, times(1)).removeMember(any(), eq("user_id"));
     }
+
+    @Test
+    public void testAddMember() throws Exception {
+
+        when(groupsDAO.findGroupByParentAndName("", "LBT")).thenReturn(Optional.of(lbt));
+        when(groupsDAO.findGroupByParentAndName("lbt_id", "INAF")).thenReturn(Optional.of(inaf));
+
+        String userId = "target_user";
+
+        MembershipEntity membership = new MembershipEntity();
+        membership.setGroupId(lbt.getId());
+        membership.setUserId(userId);
+
+        mockMvc.perform(post("/membership")
+                .param("group", "LBT.INAF")
+                .param("user_id", userId)
+                .accept(MediaType.TEXT_PLAIN)
+                .contentType(MediaType.APPLICATION_FORM_URLENCODED))
+                .andExpect(status().isOk());
+
+        verify(membershipManager, times(1)).addMember(eq(inaf), eq(userId));
+    }
+
+    @Test
+    public void testRemoveMember() throws Exception {
+
+        mockMvc.perform(delete("/membership?group=LBT.INAF&user_id=userId"))
+                .andExpect(status().isNoContent());
+
+        verify(membershipManager, times(1)).removeMember(eq(inaf), eq("userId"));
+    }
+
+    @Test
+    public void testGetMembers() throws Exception {
+
+        when(membershipManager.getUserGroups(any(), eq("userId"))).thenReturn(new ArrayList<>());
+
+        mockMvc.perform(get("/membership?group=LBT&user_id=userId"))
+                .andExpect(status().isOk());
+
+        verify(membershipManager, times(1)).getUserGroups(any(), eq("userId"));
+    }
 }

gms/src/test/java/it/inaf/ia2/gms/controller/PermissionsControllerTest.java

 package it.inaf.ia2.gms.controller;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
+import static it.inaf.ia2.gms.controller.ControllersMockData.*;
 import it.inaf.ia2.gms.manager.GroupsManager;
 import it.inaf.ia2.gms.manager.PermissionsManager;
 import it.inaf.ia2.gms.model.Permission;
+import it.inaf.ia2.gms.model.RapUserPermission;
 import it.inaf.ia2.gms.model.request.AddPermissionRequest;
+import it.inaf.ia2.gms.persistence.GroupsDAO;
 import it.inaf.ia2.gms.persistence.model.GroupEntity;
+import it.inaf.ia2.gms.persistence.model.PermissionEntity;
+import it.inaf.ia2.gms.service.GroupNameService;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
 import static org.hamcrest.CoreMatchers.is;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
@@ -22,6 +31,7 @@ import org.springframework.test.web.servlet.MockMvc;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 import org.springframework.test.web.servlet.setup.MockMvcBuilders;
@@ -35,6 +45,9 @@ public class PermissionsControllerTest {
     @Mock
     private PermissionsManager permissionsManager;
 
+    @Mock
+    private GroupsDAO groupsDAO;
+
     @InjectMocks
     private PermissionsController controller;
 
@@ -46,6 +59,7 @@ public class PermissionsControllerTest {
 
     @Before
     public void init() {
+        controller.groupNameService = new GroupNameService(groupsDAO);
         mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
 
         group = new GroupEntity();
@@ -61,7 +75,7 @@ public class PermissionsControllerTest {
 
         when(permissionsManager.getDirectUserPermission(eq(group), eq("user_id"))).thenReturn(Permission.MANAGE_MEMBERS);
 
-        mockMvc.perform(get("/permission?groupId=group_id&userId=user_id")
+        mockMvc.perform(get("/ui/permission?groupId=group_id&userId=user_id")
                 .contentType(MediaType.APPLICATION_JSON))
                 .andExpect(status().isOk())
                 .andExpect(jsonPath("$.permission", is("MANAGE_MEMBERS")));
@@ -70,13 +84,13 @@ public class PermissionsControllerTest {
     @Test
     public void testGetInexistentPermission() throws Exception {
 
-        mockMvc.perform(get("/permission?groupId=group_id&userId=user_id")
+        mockMvc.perform(get("/ui/permission?groupId=group_id&userId=user_id")
                 .contentType(MediaType.APPLICATION_JSON))
                 .andExpect(status().isNoContent());
     }
 
     @Test
-    public void testAddPermission() throws Exception {
+    public void testAddPermissionPaginated() throws Exception {
 
         AddPermissionRequest request = new AddPermissionRequest();
         request.setGroupId("group_id");
@@ -85,7 +99,7 @@ public class PermissionsControllerTest {
         request.setPaginatorPage(1);
         request.setPaginatorPageSize(10);
 
-        mockMvc.perform(post("/permission")
+        mockMvc.perform(post("/ui/permission")
                 .content(mapper.writeValueAsString(request))
                 .contentType(MediaType.APPLICATION_JSON))
                 .andExpect(status().isCreated())
@@ -95,12 +109,80 @@ public class PermissionsControllerTest {
     }
 
     @Test
-    public void testRemovePermission() throws Exception {
+    public void testRemovePermissionPaginated() throws Exception {
 
-        mockMvc.perform(delete("/permission?groupId=group_id&userId=user_id&paginatorPage=1&paginatorPageSize=10"))
+        mockMvc.perform(delete("/ui/permission?groupId=group_id&userId=user_id&paginatorPage=1&paginatorPageSize=10"))
                 .andExpect(status().isOk())
                 .andExpect(jsonPath("$.currentPage", is(1)));
 
         verify(permissionsManager, times(1)).removePermission(eq(group), eq("user_id"));
     }
+
+    @Test
+    public void testGetGroupPermissions() throws Exception {
+
+        when(groupsDAO.findGroupByParentAndName("", "LBT")).thenReturn(Optional.of(getLbtGroup()));
+        when(groupsDAO.findGroupByParentAndName("lbt_id", "INAF")).thenReturn(Optional.of(getInafGroup()));
+
+        List<RapUserPermission> permissions = new ArrayList<>();
+        RapUserPermission up = new RapUserPermission();
+        up.setUser(getRapUser());
+        up.setPermission(Permission.ADMIN);
+        permissions.add(up);
+        when(permissionsManager.getAllPermissions(any())).thenReturn(permissions);
+
+        mockMvc.perform(get("/permission?group=LBT.INAF").principal(getPrincipal())
+                .accept(MediaType.TEXT_PLAIN))
+                .andExpect(status().isOk())
+                .andExpect(content().string("rap_user ADMIN\n"));
+    }
+
+    @Test
+    public void testAddPermission() throws Exception {
+
+        String userId = "target_user";
+        Permission permission = Permission.ADMIN;
+
+        GroupEntity lbt = getLbtGroup();
+        GroupEntity inaf = getInafGroup();
+
+        when(groupsDAO.findGroupByParentAndName("", "LBT")).thenReturn(Optional.of(lbt));
+        when(groupsDAO.findGroupByParentAndName("lbt_id", "INAF")).thenReturn(Optional.of(inaf));
+
+        PermissionEntity permissionEntity = new PermissionEntity();
+        permissionEntity.setGroupId(inaf.getId());
+        permissionEntity.setUserId(userId);
+        permissionEntity.setPermission(permission);
+        permissionEntity.setGroupPath(inaf.getPath());
+
+        when(permissionsManager.addPermission(eq(inaf), eq(userId),
+                eq(permission))).thenReturn(permissionEntity);
+
+        mockMvc.perform(post("/permission")
+                .param("group", "LBT.INAF")
+                .param("user_id", userId)
+                .param("permission", permission.toString())
+                .accept(MediaType.TEXT_PLAIN)
+                .contentType(MediaType.APPLICATION_FORM_URLENCODED))
+                .andExpect(status().isOk());
+
+        verify(permissionsManager, times(1))
+                .addPermission(eq(inaf), eq(userId), eq(permission));
+    }
+
+    @Test
+    public void testRemovePermission() throws Exception {
+
+        GroupEntity lbt = getLbtGroup();
+        GroupEntity inaf = getInafGroup();
+
+        when(groupsDAO.findGroupByParentAndName("", "LBT")).thenReturn(Optional.of(lbt));
+        when(groupsDAO.findGroupByParentAndName("lbt_id", "INAF")).thenReturn(Optional.of(inaf));
+
+        mockMvc.perform(delete("/permission?group=LBT.INAF&user_id=userId")
+                .accept(MediaType.TEXT_PLAIN))
+                .andExpect(status().isNoContent());
+
+        verify(permissionsManager, times(1)).removePermission(eq(inaf), eq("userId"));
+    }
 }

gms/src/test/java/it/inaf/ia2/gms/controller/SearchControllerTest.java

@@ -8,11 +8,14 @@ import it.inaf.ia2.gms.model.response.UserSearchResponse;
 import it.inaf.ia2.gms.service.SearchService;
 import java.util.ArrayList;
 import javax.servlet.http.HttpServletRequest;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.argThat;
 import static org.mockito.ArgumentMatchers.eq;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
@@ -53,13 +56,20 @@ public class SearchControllerTest {
 
         PaginatedData<SearchResponseItem> response = new PaginatedData<>(new ArrayList<>(), 1, 10);
 
-        when(searchService.search(any(), any(), anyInt(), anyInt())).thenReturn(response);
+        when(searchService.search(any(), any())).thenReturn(response);
 
-        mockMvc.perform(get("/search?query=searchText&page=1&pageSize=10")
+        mockMvc.perform(get("/ui/search?query=searchText&paginatorPage=1&paginatorPageSize=10&groups=false")
                 .contentType(MediaType.APPLICATION_JSON_VALUE))
                 .andExpect(status().isOk());
 
-        verify(searchService, times(1)).search(eq("searchText"), eq("admin_id"), eq(1), eq(10));
+        verify(searchService, times(1)).search(argThat(req -> {
+            assertEquals("searchText", req.getQuery());
+            assertEquals(1, req.getPaginatorPage());
+            assertEquals(10, req.getPaginatorPageSize());
+            assertTrue(req.isUsers());
+            assertFalse(req.isGroups());
+            return true;
+        }), eq("admin_id"));
     }
 
     @Test
@@ -67,7 +77,7 @@ public class SearchControllerTest {
 
         when(searchService.getUserSearchResult(any(), any())).thenReturn(new UserSearchResponse());
 
-        mockMvc.perform(get("/search/user/user_id")
+        mockMvc.perform(get("/ui/search/user/user_id")
                 .contentType(MediaType.APPLICATION_JSON_VALUE))
                 .andExpect(status().isOk());
 

gms/src/test/java/it/inaf/ia2/gms/manager/GroupsManagerTest.java

+package it.inaf.ia2.gms.manager;
+
+import it.inaf.ia2.gms.exception.UnauthorizedException;
+import it.inaf.ia2.gms.persistence.LoggingDAO;
+import it.inaf.ia2.gms.persistence.model.GroupEntity;
+import it.inaf.ia2.gms.service.GroupsService;
+import static org.junit.Assert.assertTrue;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class GroupsManagerTest {
+
+    @Mock
+    private GroupsService groupsService;
+    @Mock
+    private PermissionsManager permissionsManager;
+    @Mock
+    private LoggingDAO loggingDAO;
+
+    @InjectMocks
+    private GroupsManager groupsManager;
+
+    @Test
+    public void testRootAlwaysReadable() {
+
+        GroupEntity root = new GroupEntity();
+        root.setName("ROOT");
+        root.setId(GroupsService.ROOT);
+        root.setPath("");
+
+        groupsManager.verifyUserCanReadGroup(root);
+    }
+
+    @Test
+    public void testVerifyUserCanReadGroupFails() {
+
+        boolean exception = false;
+
+        GroupEntity group = new GroupEntity();
+        group.setName("group_name");
+        group.setId("group_id");
+        group.setPath("group_id");
+
+        try {
+            groupsManager.verifyUserCanReadGroup(group);
+        } catch (UnauthorizedException ex) {
+            exception = true;
+        }
+
+        assertTrue(exception);
+    }
+}

gms/src/test/java/it/inaf/ia2/gms/manager/InvitedRegistrationManagerTest.java

@@ -130,7 +130,7 @@ public class InvitedRegistrationManagerTest {
         invitedRegistrationManager.completeInvitedRegistrationIfNecessary();
 
         verify(membershipsDAO, times(2)).addMember(any());
-        verify(permissionsService, times(2)).addPermission(any(), any(), any());
+        verify(permissionsService, times(2)).addPermission(any(), any(), any(), any());
     }
 
     @Test
@@ -164,6 +164,6 @@ public class InvitedRegistrationManagerTest {
         invitedRegistrationManager.completeInvitedRegistrationIfNecessary();
 
         verify(membershipsDAO, times(1)).addMember(any());
-        verify(permissionsService, times(1)).addPermission(any(), any(), any());
+        verify(permissionsService, times(1)).addPermission(any(), any(), any(), any());
     }
 }

gms/src/test/java/it/inaf/ia2/gms/manager/PermissionsManagerTest.java

@@ -5,11 +5,13 @@ import it.inaf.ia2.gms.model.Permission;
 import it.inaf.ia2.gms.persistence.LoggingDAO;
 import it.inaf.ia2.gms.persistence.model.GroupEntity;
 import it.inaf.ia2.gms.persistence.model.PermissionEntity;
+import it.inaf.ia2.gms.service.GroupsService;
 import it.inaf.ia2.gms.service.PermissionsService;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import javax.servlet.http.HttpServletRequest;
+import static org.junit.Assert.assertEquals;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -54,7 +56,7 @@ public class PermissionsManagerTest {
 
         permissionsManager.addPermission(group, TARGET_USER_ID, Permission.VIEW_MEMBERS);
 
-        verify(permissionsService, times(1)).addPermission(eq(group), eq(TARGET_USER_ID), eq(Permission.VIEW_MEMBERS));
+        verify(permissionsService, times(1)).addPermission(eq(group), eq(TARGET_USER_ID), eq(Permission.VIEW_MEMBERS), eq(USER_ID));
     }
 
     @Test
@@ -67,7 +69,7 @@ public class PermissionsManagerTest {
 
         permissionsManager.addPermission(group, TARGET_USER_ID, Permission.MANAGE_MEMBERS);
 
-        verify(permissionsService, times(1)).addPermission(eq(group), eq(TARGET_USER_ID), eq(Permission.MANAGE_MEMBERS));
+        verify(permissionsService, times(1)).addPermission(eq(group), eq(TARGET_USER_ID), eq(Permission.MANAGE_MEMBERS), eq(USER_ID));
     }
 
     @Test(expected = UnauthorizedException.class)
@@ -137,6 +139,18 @@ public class PermissionsManagerTest {
         permissionsManager.removePermission(group, TARGET_USER_ID);
     }
 
+    @Test
+    public void testGetCurrentUserPermissionAlwaysTraverseRoot() {
+        when(permissionsService.findUserPermissions(any(), any())).thenReturn(new ArrayList<>());
+
+        GroupEntity root = new GroupEntity();
+        root.setName("ROOT");
+        root.setId(GroupsService.ROOT);
+        root.setPath("");
+
+        assertEquals(Permission.TRAVERSE, permissionsManager.getCurrentUserPermission(root));
+    }
+
     private List<PermissionEntity> getUserPermissions(GroupEntity group, Permission permission) {
         PermissionEntity entity = new PermissionEntity();
         entity.setPermission(permission);

gms/src/test/java/it/inaf/ia2/gms/persistence/GroupsDAOTest.java

@@ -5,6 +5,7 @@ import it.inaf.ia2.gms.HooksConfig;
 import it.inaf.ia2.gms.model.GroupBreadcrumb;
 import it.inaf.ia2.gms.persistence.model.GroupEntity;
 import it.inaf.ia2.gms.service.hook.GroupsHook;
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -43,7 +44,6 @@ public class GroupsDAOTest {
     @Before
     public void setUp() {
         dao = new GroupsDAO(dataSource);
-        dao.groupsHook = groupsHook;
     }
 
     @Test
@@ -56,7 +56,7 @@ public class GroupsDAOTest {
         root.setPath("");
         dao.createGroup(root);
 
-        verify(groupsHook, times(1)).beforeCreate(eq(root));
+        dao.groupsHook = groupsHook;
 
         GroupEntity lbt = new GroupEntity();
         lbt.setId(getNewGroupId());
@@ -64,20 +64,30 @@ public class GroupsDAOTest {
         lbt.setPath(lbt.getId());
         dao.createGroup(lbt);
 
+        verify(groupsHook, times(1)).beforeCreate(eq(lbt));
+
         GroupEntity tng = new GroupEntity();
         tng.setId(getNewGroupId());
         tng.setName("TNG");
         tng.setPath(tng.getId());
         dao.createGroup(tng);
 
+        verify(groupsHook, times(1)).beforeCreate(eq(tng));
+
         GroupEntity lbtInaf = new GroupEntity();
         lbtInaf.setId(getNewGroupId());
         lbtInaf.setName("INAF");
         lbtInaf.setPath(lbt.getId() + "." + lbtInaf.getId());
         dao.createGroup(lbtInaf);
 
+        GroupEntity lbtInafP1 = new GroupEntity();
+        lbtInafP1.setId(getNewGroupId());
+        lbtInafP1.setName("P1");
+        lbtInafP1.setPath(lbt.getId() + "." + lbtInaf.getId() + "." + lbtInafP1.getId());
+        dao.createGroup(lbtInafP1);
+
         // Check count
-        assertEquals(4, dao.count());
+        assertEquals(5, dao.count());
 
         // Find by id
         Optional<GroupEntity> group = dao.findGroupById(lbtInaf.getId());
@@ -88,10 +98,6 @@ public class GroupsDAOTest {
         assertTrue(group.isPresent());
         assertEquals(lbtInaf, group.get());
 
-        // Find unexisting group
-        group = dao.findGroupById("not-found");
-        assertFalse(group.isPresent());
-
         // Sub list
         List<GroupEntity> groups = dao.getDirectSubGroups(root.getPath());
         assertEquals(2, groups.size());
@@ -104,8 +110,9 @@ public class GroupsDAOTest {
 
         // All children
         groups = dao.getAllChildren(root.getPath());
-        assertEquals(3, groups.size());
-        assertEquals("INAF", groups.get(0).getName()); // order by path DESC
+        assertEquals(4, groups.size());
+        assertEquals("P1", groups.get(0).getName()); // order by path DESC
+        assertEquals("INAF", groups.get(1).getName());
 
         // Group by parent and name
         Optional<GroupEntity> optGroup = dao.findGroupByParentAndName(root.getPath(), lbt.getName());
@@ -123,7 +130,7 @@ public class GroupsDAOTest {
         Map<String, String> completeGroupNames = dao.getGroupCompleteNamesFromId(groupIds);
         assertEquals(2, completeGroupNames.size());
         assertEquals("LBT", completeGroupNames.get(lbt.getId()));
-        assertEquals("LBT.INAF", completeGroupNames.get(groups.get(0).getId()));
+        assertEquals("LBT.INAF.P1", completeGroupNames.get(groups.get(0).getId()));
 
         // Children map
         Map<String, Boolean> childrenMap = dao.getHasChildrenMap(Sets.newSet(root.getId()));
@@ -135,7 +142,7 @@ public class GroupsDAOTest {
         assertTrue(childrenMap.get(lbt.getId()));
         assertFalse(childrenMap.get(tng.getId()));
 
-        // Rename
+        // Update
         String newName = "renamed";
         tng.setName(newName);
         dao.updateGroup(tng);
@@ -151,6 +158,28 @@ public class GroupsDAOTest {
         assertEquals(lbt.getName(), breadcrumbs.get(1).getGroupName());
         assertEquals(lbtInaf.getName(), breadcrumbs.get(2).getGroupName());
 
+        // Search
+        assertEquals(1, dao.searchGroups("renam").size());
+        assertTrue(dao.searchGroups("invalid-name").isEmpty());
+
+        // Find by names
+        List<GroupEntity> groupsByName = dao.findGroupsByNames(Arrays.asList("LBT", "INAF"));
+        assertEquals(2, groupsByName.size());
+        assertEquals("LBT", groupsByName.get(0).getName());
+        assertEquals("INAF", groupsByName.get(1).getName());
+
+        // Find by ids
+        assertEquals(2, dao.findGroupsByIds(new HashSet<>(Arrays.asList(lbt.getId(), tng.getId()))).size());
+
+        // Get direct children
+        List<GroupEntity> lbtChildren = dao.getDirectSubGroups(lbt.getPath());
+        assertEquals(1, lbtChildren.size());
+        assertEquals("INAF", lbtChildren.get(0).getName());
+
+        // Get direct children with filter
+        assertEquals(1, dao.getDirectSubGroups(lbt.getPath(), "INA").size());
+        assertTrue(dao.getDirectSubGroups(lbt.getPath(), "invalid-name").isEmpty());
+
         // Delete
         dao.deleteGroup(lbtInaf);
         groups = dao.getDirectSubGroups(lbt.getId());
@@ -163,8 +192,68 @@ public class GroupsDAOTest {
         return UUID.randomUUID().toString().replaceAll("-", "");
     }
 
+    @Test
+    public void testFields() {
+
+        GroupEntity group = new GroupEntity();
+        group.setId("group_id");
+        group.setName("group_name");
+        group.setPath("group_path");
+        group.setLeaf(true);
+        group.setLocked(true);
+        group.setCreatedBy("creator_id");
+
+        dao.createGroup(group);
+
+        GroupEntity savedGroup = dao.findGroupById("group_id").get();
+
+        assertEquals("group_id", savedGroup.getId());
+        assertEquals("group_name", savedGroup.getName());
+        assertEquals("group_path", savedGroup.getPath());
+        assertTrue(savedGroup.isLeaf());
+        assertTrue(savedGroup.isLocked());
+        assertEquals("creator_id", savedGroup.getCreatedBy());
+
+        group.setName("new_name");
+        group.setLeaf(false);
+        group.setLocked(false);
+
+        dao.updateGroup(group);
+
+        savedGroup = dao.findGroupById("group_id").get();
+
+        assertEquals("new_name", savedGroup.getName());
+        assertFalse(savedGroup.isLeaf());
+        assertFalse(savedGroup.isLocked());
+    }
+
+    @Test
+    public void testGetInexistentGroupById() {
+        assertTrue(dao.findGroupById("not-found").isEmpty());
+    }
+
     @Test
     public void testGroupCompleteNamesEmptyInput() {
         assertTrue(dao.getGroupCompleteNamesFromId(new HashSet<>()).isEmpty());
     }
+
+    @Test
+    public void testGetHasChildrenMapEmptyInput() {
+        assertTrue(dao.getHasChildrenMap(new HashSet<>()).isEmpty());
+    }
+
+    @Test
+    public void testFindGroupsByIdsEmtpyInput() {
+        assertTrue(dao.findGroupsByIds(new HashSet<>()).isEmpty());
+    }
+
+    @Test
+    public void findInexistentGroupByParentAndName() {
+        assertTrue(dao.findGroupByParentAndName("", "not-exists").isEmpty());
+    }
+
+    @Test
+    public void findInexistentGroupByPath() {
+        assertTrue(dao.findGroupByPath("not.exists").isEmpty());
+    }
 }

gms/src/test/java/it/inaf/ia2/gms/persistence/InvitedRegistrationDAOTest.java

@@ -94,7 +94,35 @@ public class InvitedRegistrationDAOTest {
         groupsIds.add(group2.getId());
         dao.deleteAllGroupsInvitedRegistrations(groupsIds);
 
+        assertTrue(dao.getInvitedRegistrationFromToken("token_hash").isEmpty());
+
+        dao.addInvitedRegistration(reg);
+        assertEquals(1, dao.getPendingInvitedRegistrationsForGroup("group1").size());
+        assertEquals(1, dao.getPendingInvitedRegistrationsForGroup("group2").size());
+
+        dao.deleteInvitedRegistrationRequest(reg.getId(), "group1");
+        assertTrue(dao.getPendingInvitedRegistrationsForGroup("group1").isEmpty());
+        assertEquals(1, dao.getPendingInvitedRegistrationsForGroup("group2").size());
+
+        dao.deleteInvitedRegistrationRequest(reg.getId(), "group2");
+
         groupsDAO.deleteGroup(group1);
         groupsDAO.deleteGroup(group2);
     }
+
+    @Test
+    public void testDeleteAllGroupsInvitedRegistrationsEmptyInput() {
+        dao.deleteAllGroupsInvitedRegistrations(new ArrayList<>());
+    }
+
+    @Test
+    public void testgetInvitedRegistrationsFromEmailAddressesEmptyInput() {
+        boolean exception = false;
+        try {
+            dao.getInvitedRegistrationsFromEmailAddresses(new ArrayList<>());
+        } catch (IllegalArgumentException ex) {
+            exception = true;
+        }
+        assertTrue(exception);
+    }
 }

gms/src/test/java/it/inaf/ia2/gms/persistence/LoggingDAOTest.java

+package it.inaf.ia2.gms.persistence;
+
+import it.inaf.ia2.gms.DataSourceConfig;
+import it.inaf.ia2.gms.persistence.model.ActionType;
+import javax.servlet.http.HttpServletRequest;
+import javax.sql.DataSource;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+
+@RunWith(SpringRunner.class)
+@ContextConfiguration(classes = DataSourceConfig.class)
+public class LoggingDAOTest {
+
+    @MockBean
+    private HttpServletRequest request;
+
+    @Autowired
+    private DataSource dataSource;
+
+    private LoggingDAO dao;
+
+    @Before
+    public void setUp() {
+        dao = new LoggingDAO(dataSource);
+    }
+
+    @Test
+    public void testLogAction() {
+        dao.logAction(ActionType.GROUP_CREATED, "description");
+    }
+
+    @Test
+    public void testlogException() {
+        dao.logException(new RuntimeException("msg"));
+    }
+}

gms/src/test/java/it/inaf/ia2/gms/persistence/MembershipsDAOTest.java

+package it.inaf.ia2.gms.persistence;
+
+import it.inaf.ia2.gms.DataSourceConfig;
+import it.inaf.ia2.gms.persistence.model.GroupEntity;
+import it.inaf.ia2.gms.persistence.model.MembershipEntity;
+import java.util.ArrayList;
+import java.util.Arrays;
+import javax.sql.DataSource;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+
+@RunWith(SpringRunner.class)
+@ContextConfiguration(classes = DataSourceConfig.class)
+public class MembershipsDAOTest {
+
+    private static final String USER_1 = "user-1";
+    private static final String USER_2 = "user-2";
+
+    @Autowired
+    private DataSource dataSource;
+
+    private GroupsDAO groupsDAO;
+    private MembershipsDAO membershipsDAO;
+
+    @Before
+    public void setUp() {
+        groupsDAO = new GroupsDAO(dataSource);
+        membershipsDAO = new MembershipsDAO(dataSource);
+    }
+
+    @Test
+    public void testAddAndRemoveMembers() {
+        groupsDAO.createGroup(groupEntity("A"));
+        groupsDAO.createGroup(groupEntity("B"));
+
+        assertTrue(membershipsDAO.findByGroup("A").isEmpty());
+
+        membershipsDAO.addMember(membershipEntity(USER_1, "A"));
+        membershipsDAO.addMember(membershipEntity(USER_1, "B"));
+        membershipsDAO.addMember(membershipEntity(USER_2, "B"));
+
+        assertTrue(membershipsDAO.findByGroup("A").contains(membershipEntity(USER_1, "A")));
+        assertEquals(3, membershipsDAO.findByGroups(Arrays.asList("A", "B")).size());
+        assertEquals(2, membershipsDAO.getUserMemberships(USER_1).size());
+        assertEquals(1, membershipsDAO.getUserMemberships(USER_2, "").size());
+
+        assertTrue(membershipsDAO.isMemberOf(USER_1, "B"));
+        membershipsDAO.removeMembership("B", USER_1);
+        assertFalse(membershipsDAO.isMemberOf(USER_1, "B"));
+
+        assertTrue(membershipsDAO.isMemberOf(USER_1, "A"));
+        assertTrue(membershipsDAO.isMemberOf(USER_2, "B"));
+        membershipsDAO.deleteAllGroupsMembership(Arrays.asList("A", "B"));
+        assertFalse(membershipsDAO.isMemberOf(USER_1, "A"));
+        assertFalse(membershipsDAO.isMemberOf(USER_2, "B"));
+    }
+
+    @Test
+    public void testFindByGroupsEmptyList() {
+        assertTrue(membershipsDAO.findByGroups(new ArrayList<>()).isEmpty());
+    }
+
+    @Test
+    public void testDeleteAllGroupsMembershipEmptyList() {
+        membershipsDAO.deleteAllGroupsMembership(new ArrayList<>());
+    }
+
+    private GroupEntity groupEntity(String groupId) {
+        GroupEntity groupEntity = new GroupEntity();
+        groupEntity.setId(groupId);
+        groupEntity.setName(groupId);
+        groupEntity.setPath(groupId);
+        groupEntity.setLeaf(false);
+        return groupEntity;
+    }
+
+    private MembershipEntity membershipEntity(String userId, String groupId) {
+        MembershipEntity membershipEntity = new MembershipEntity();
+        membershipEntity.setUserId(userId);
+        membershipEntity.setGroupId(groupId);
+        return membershipEntity;
+    }
+}

gms/src/test/java/it/inaf/ia2/gms/persistence/NestedGroupsIntegrationTest.java

@@ -64,12 +64,12 @@ public class NestedGroupsIntegrationTest {
 
         // Setup groups
         GroupEntity root = groupsManager.getRoot();
-        GroupEntity lbt = groupsService.addGroup(root, "LBT", false);
-        GroupEntity tng = groupsService.addGroup(root, "TNG", false);
-        GroupEntity radio = groupsService.addGroup(root, "Radio", false);
-        GroupEntity lbtInaf = groupsService.addGroup(lbt, "INAF", false);
-        GroupEntity lbtInafProgram1 = groupsService.addGroup(lbtInaf, "P1", false);
-        GroupEntity lbtInafProgram2 = groupsService.addGroup(lbtInaf, "P2", false);
+        GroupEntity lbt = groupsService.addGroup(root, "LBT", false, "creator_id");
+        GroupEntity tng = groupsService.addGroup(root, "TNG", false, "creator_id");
+        GroupEntity radio = groupsService.addGroup(root, "Radio", false, "creator_id");
+        GroupEntity lbtInaf = groupsService.addGroup(lbt, "INAF", false, "creator_id");
+        GroupEntity lbtInafProgram1 = groupsService.addGroup(lbtInaf, "P1", false, "creator_id");
+        GroupEntity lbtInafProgram2 = groupsService.addGroup(lbtInaf, "P2", false, "creator_id");
 
         GroupsRequest request = new GroupsRequest();
         request.setPaginatorPage(1);

gms/src/test/java/it/inaf/ia2/gms/persistence/PermissionsDAOTest.java

@@ -4,9 +4,13 @@ import it.inaf.ia2.gms.DataSourceConfig;
 import it.inaf.ia2.gms.model.Permission;
 import it.inaf.ia2.gms.persistence.model.PermissionEntity;
 import it.inaf.ia2.gms.persistence.model.GroupEntity;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import javax.sql.DataSource;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 import org.junit.Before;
 import org.junit.Test;
@@ -19,6 +23,8 @@ import org.springframework.test.context.junit4.SpringRunner;
 @ContextConfiguration(classes = DataSourceConfig.class)
 public class PermissionsDAOTest {
 
+    private static final String USER_ID = "user_id";
+
     @Autowired
     private DataSource dataSource;
 
@@ -34,41 +40,99 @@ public class PermissionsDAOTest {
     @Test
     public void testAll() {
 
-        GroupEntity root = new GroupEntity();
-        root.setId("ROOT");
-        root.setName("ROOT");
-        root.setPath("");
-        groupsDAO.createGroup(root);
-
-        String userId = "user_id";
+        GroupEntity group = groupEntity("A");
 
-        PermissionEntity permission = new PermissionEntity();
-        permission.setGroupId(root.getId());
-        permission.setUserId(userId);
-        permission.setPermission(Permission.ADMIN);
-        permission.setGroupPath(root.getPath());
+        PermissionEntity permission = permissionEntity(group, USER_ID, Permission.ADMIN);
 
         permissionsDAO.createOrUpdatePermission(permission);
 
-        List<PermissionEntity> permissions = permissionsDAO.findUserPermissions(userId);
+        List<PermissionEntity> permissions = permissionsDAO.findUserPermissions(USER_ID);
 
         assertEquals(1, permissions.size());
         assertEquals(Permission.ADMIN, permissions.get(0).getPermission());
-        assertEquals(userId, permissions.get(0).getUserId());
+        assertEquals(USER_ID, permissions.get(0).getUserId());
+        assertEquals("admin1", permissions.get(0).getSetBy());
+        assertNotNull(permissions.get(0).getUpdateTime());
 
-        permissions = permissionsDAO.findUserPermissions(userId, root.getPath());
+        permissions = permissionsDAO.findUserPermissions(USER_ID, group.getPath());
         assertEquals(1, permissions.size());
 
-        permissions = permissionsDAO.getGroupsPermissions(root.getId());
+        permissions = permissionsDAO.getGroupsPermissions(group.getId());
         assertEquals(1, permissions.size());
 
         // test upsert
         permission.setPermission(Permission.MANAGE_MEMBERS);
+        permission.setSetBy("admin2");
         permissionsDAO.createOrUpdatePermission(permission);
 
+        permissions = permissionsDAO.findUserPermissions(USER_ID);
+        assertEquals(1, permissions.size());
+        assertEquals(Permission.MANAGE_MEMBERS, permissions.get(0).getPermission());
+        assertEquals("admin2", permissions.get(0).getSetBy());
+        assertNotNull(permissions.get(0).getUpdateTime());
+
+        // test update
+        permission.setPermission(Permission.VIEW_MEMBERS);
+        permission.setSetBy("admin3");
+        permissionsDAO.updatePermission(permission);
+
+        permissions = permissionsDAO.findUserPermissions(USER_ID);
+        assertEquals(1, permissions.size());
+        assertEquals(Permission.VIEW_MEMBERS, permissions.get(0).getPermission());
+        assertEquals("admin3", permissions.get(0).getSetBy());
+        assertNotNull(permissions.get(0).getUpdateTime());
+
+        assertTrue(permissionsDAO.findPermissionEntity(group.getId(), USER_ID).isPresent());
+
         permissionsDAO.deletePermission(permission.getGroupId(), permission.getUserId());
 
-        permissions = permissionsDAO.findUserPermissions(userId);
+        permissions = permissionsDAO.findUserPermissions(USER_ID);
         assertTrue(permissions.isEmpty());
     }
+
+    @Test
+    public void testDeleteAllGroupsPermissions() {
+
+        GroupEntity groupB = groupEntity("B");
+        GroupEntity groupC = groupEntity("C");
+
+        PermissionEntity permissionB = permissionEntity(groupB, USER_ID, Permission.ADMIN);
+        PermissionEntity permissionC = permissionEntity(groupC, USER_ID, Permission.VIEW_MEMBERS);
+
+        permissionsDAO.createOrUpdatePermission(permissionB);
+        permissionsDAO.createOrUpdatePermission(permissionC);
+
+        assertTrue(permissionsDAO.findPermissionEntity(groupB.getId(), USER_ID).isPresent());
+        assertTrue(permissionsDAO.findPermissionEntity(groupC.getId(), USER_ID).isPresent());
+
+        permissionsDAO.deleteAllGroupsPermissions(Arrays.asList(groupB.getId(), groupC.getId()));
+
+        assertFalse(permissionsDAO.findPermissionEntity(groupB.getId(), USER_ID).isPresent());
+        assertFalse(permissionsDAO.findPermissionEntity(groupC.getId(), USER_ID).isPresent());
+    }
+
+    @Test
+    public void testDeleteAllGroupsPermissionsEmptyList() {
+        permissionsDAO.deleteAllGroupsPermissions(new ArrayList<>());
+    }
+
+    private GroupEntity groupEntity(String groupId) {
+        GroupEntity groupEntity = new GroupEntity();
+        groupEntity.setId(groupId);
+        groupEntity.setName(groupId);
+        groupEntity.setPath(groupId);
+        groupEntity.setLeaf(false);
+        groupsDAO.createGroup(groupEntity);
+        return groupEntity;
+    }
+
+    private PermissionEntity permissionEntity(GroupEntity group, String userId, Permission permission) {
+        PermissionEntity permissionEntity = new PermissionEntity();
+        permissionEntity.setGroupId(group.getId());
+        permissionEntity.setUserId(userId);
+        permissionEntity.setPermission(permission);
+        permissionEntity.setSetBy("admin1");
+        permissionEntity.setGroupPath(group.getPath());
+        return permissionEntity;
+    }
 }

gms/src/test/java/it/inaf/ia2/gms/service/GroupNameServiceTest.java

@@ -11,6 +11,7 @@ import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import static org.mockito.ArgumentMatchers.any;
@@ -76,4 +77,41 @@ public class GroupNameServiceTest {
         assertEquals(1, names.get("ROOT").size());
         assertEquals("ROOT", names.get("ROOT").get(0));
     }
+
+    @Test
+    public void extractGroupNamesTest() {
+
+        List<String> names = groupNameService.extractGroupNames("group1.people.name\\.surname.another\\.composite");
+
+        assertEquals(4, names.size());
+        assertEquals("group1", names.get(0));
+        assertEquals("people", names.get(1));
+        assertEquals("name.surname", names.get(2));
+        assertEquals("another.composite", names.get(3));
+    }
+
+    @Test
+    public void extractGroupNamesTestEmpty() {
+        assertTrue(groupNameService.extractGroupNames("").isEmpty());
+    }
+
+    @Test
+    public void extractGroupNamesTestNull() {
+        assertTrue(groupNameService.extractGroupNames(null).isEmpty());
+    }
+
+    @Test
+    public void testGetShortGroupNameOld() {
+        assertEquals("INAF", groupNameService.getShortGroupName("LBT.INAF", Optional.of("LBT.")));
+    }
+
+    @Test
+    public void testGetShortGroupName() {
+        assertEquals("INAF", groupNameService.getShortGroupName("LBT.INAF", Optional.of("LBT")));
+    }
+
+    @Test
+    public void testGetShortGroupNameEmpty() {
+        assertEquals("LBT.INAF", groupNameService.getShortGroupName("LBT.INAF", Optional.of("")));
+    }
 }

gms/src/test/java/it/inaf/ia2/gms/service/GroupsServiceTest.java

+package it.inaf.ia2.gms.service;
+
+import static it.inaf.ia2.gms.controller.ControllersMockData.*;
+import it.inaf.ia2.gms.exception.UnauthorizedException;
+import it.inaf.ia2.gms.persistence.GroupsDAO;
+import it.inaf.ia2.gms.persistence.InvitedRegistrationDAO;
+import it.inaf.ia2.gms.persistence.LoggingDAO;
+import it.inaf.ia2.gms.persistence.MembershipsDAO;
+import it.inaf.ia2.gms.persistence.PermissionsDAO;
+import it.inaf.ia2.gms.persistence.model.GroupEntity;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class GroupsServiceTest {
+    
+    @Mock
+    private GroupsDAO groupsDAO;
+    @Mock
+    private PermissionsDAO permissionsDAO;
+    @Mock
+    private MembershipsDAO membershipsDAO;
+    @Mock
+    private InvitedRegistrationDAO invitedRegistrationDAO;
+    @Mock
+    private LoggingDAO loggingDAO;
+    
+    @InjectMocks
+    private GroupsService groupsService;
+    
+    private final GroupEntity root = group("ROOT", "ROOT", "");
+    
+    @Test
+    public void testAddGroup() {
+        
+        GroupEntity group1 = groupsService.addGroup(root, "group1", false, "creator_id");
+        
+        verify(groupsDAO, times(1)).createGroup(argThat(g -> "group1".equals(g.getName())));
+        
+        assertNotNull(group1.getId());
+        assertEquals("group1", group1.getName());
+        assertFalse(group1.isLeaf());
+        assertEquals("creator_id", group1.getCreatedBy());
+        assertNotNull(group1.getCreationTime());
+        
+        GroupEntity group2 = groupsService.addGroup(group1, "group2", true, "creator_id");
+        
+        verify(groupsDAO, times(1)).createGroup(argThat(g -> "group2".equals(g.getName())));
+        
+        assertNotNull(group2.getId());
+        assertEquals("group2", group2.getName());
+        assertTrue(group2.isLeaf());
+        assertEquals(group1.getId() + "." + group2.getId(), group2.getPath());
+    }
+    
+    @Test
+    public void testGetChildGroups() {
+        groupsService.getChildGroups(getLbtGroup(), false);
+        verify(groupsDAO, times(1)).getDirectSubGroups(getLbtGroup().getPath());
+    }
+    
+    @Test
+    public void testGetChildGroupsRecursive() {
+        groupsService.getChildGroups(getLbtGroup(), true);
+        verify(groupsDAO, times(1)).getAllChildren(getLbtGroup().getPath());
+    }
+    
+    @Test
+    public void testDeleteRootIsDenied() {
+        boolean exception = false;
+        try {
+            groupsService.deleteGroup(root);
+        } catch (UnauthorizedException ex) {
+            exception = true;
+        }
+        assertTrue(exception);
+    }
+    
+    @Test
+    public void testDeleteLockedGroupIsDenied() {
+        GroupEntity group = getLbtGroup();
+        group.setLocked(true);
+        boolean exception = false;
+        try {
+            groupsService.deleteGroup(group);
+        } catch (UnauthorizedException ex) {
+            exception = true;
+        }
+        assertTrue(exception);
+    }
+    
+    @Test
+    public void testDeleteGroup() {
+        
+        GroupEntity lbt = getLbtGroup();
+        GroupEntity inaf = getInafGroup();
+        
+        when(groupsDAO.findGroupByPath(lbt.getPath())).thenReturn(Optional.of(lbt));
+        when(groupsDAO.getAllChildren(inaf.getPath())).thenReturn(new ArrayList<>(List.of(getInafProgramGroup())));
+        
+        groupsService.deleteGroup(inaf);
+        
+        verify(groupsDAO, times(2)).deleteGroup(any());
+    }
+    
+    private GroupEntity group(String id, String name, String path) {
+        GroupEntity group = new GroupEntity();
+        group.setId(id);
+        group.setName(name);
+        group.setPath(path);
+        return group;
+    }
+}

gms/src/test/java/it/inaf/ia2/gms/service/JoinServiceTest.java

@@ -2,6 +2,7 @@ package it.inaf.ia2.gms.service;
 
 import it.inaf.ia2.gms.model.Permission;
 import it.inaf.ia2.gms.persistence.JoinDAO;
+import it.inaf.ia2.gms.persistence.LoggingDAO;
 import it.inaf.ia2.gms.persistence.MembershipsDAO;
 import it.inaf.ia2.gms.persistence.PermissionsDAO;
 import it.inaf.ia2.gms.persistence.model.GroupEntity;
@@ -37,6 +38,9 @@ public class JoinServiceTest {
     @Mock
     private JoinDAO joinDAO;
 
+    @Mock
+    private LoggingDAO loggingDAO;
+
     @InjectMocks
     private JoinService joinService;
 
@@ -44,7 +48,7 @@ public class JoinServiceTest {
     public void testJoin() {
 
         when(membershipsDAO.getUserMemberships(eq(USER_1)))
-                .thenReturn(Arrays.asList(groupEntity("A")));
+                .thenReturn(Arrays.asList(groupEntity("A"), groupEntity("C")));
 
         when(membershipsDAO.getUserMemberships(eq(USER_2)))
                 .thenReturn(Arrays.asList(groupEntity("A"), groupEntity("B")));
@@ -64,10 +68,48 @@ public class JoinServiceTest {
                         permissionEntity("D", USER_2, Permission.VIEW_MEMBERS)
                 ));
 
-        joinService.join(USER_1, USER_2);
+        String remainingUserId = joinService.join(USER_1, USER_2);
+
+        verify(joinDAO, times(1)).join(argThat(memberships -> {
+            assertEquals(1, memberships.size());
+            MembershipEntity entity = memberships.iterator().next();
+            assertEquals("B", entity.getGroupId());
+            assertEquals(USER_1, entity.getUserId());
+            return true;
+        }),
+                argThat(verifyPermissionsToAdd1()), eq(USER_2));
 
-        verify(joinDAO, times(1)).join(argThat(verifyMembershipsToAdd()),
-                argThat(verifyPermissionsToAdd()), eq(USER_2));
+        assertEquals(USER_1, remainingUserId);
+    }
+
+    @Test
+    public void testJoinReverseOrder() {
+
+        when(membershipsDAO.getUserMemberships(eq(USER_1)))
+                .thenReturn(Arrays.asList(groupEntity("C")));
+
+        when(membershipsDAO.getUserMemberships(eq(USER_2)))
+                .thenReturn(Arrays.asList(groupEntity("A"), groupEntity("B")));
+
+        when(permissionsDAO.findUserPermissions(eq(USER_1)))
+                .thenReturn(Arrays.asList(
+                        permissionEntity("C", USER_1, Permission.ADMIN),
+                        permissionEntity("D", USER_1, Permission.VIEW_MEMBERS)
+                ));
+
+        when(permissionsDAO.findUserPermissions(eq(USER_2)))
+                .thenReturn(Arrays.asList(
+                        permissionEntity("A", USER_2, Permission.ADMIN),
+                        permissionEntity("B", USER_2, Permission.VIEW_MEMBERS),
+                        permissionEntity("C", USER_2, Permission.MANAGE_MEMBERS)
+                ));
+
+        String remainingUserId = joinService.join(USER_1, USER_2);
+
+        verify(joinDAO, times(1)).join(argThat(verifyMembershipsToAdd2()),
+                argThat(verifyPermissionsToAdd2()), eq(USER_1));
+
+        assertEquals(USER_2, remainingUserId);
     }
 
     private GroupEntity groupEntity(String groupId) {
@@ -84,7 +126,7 @@ public class JoinServiceTest {
         return permissionEntity;
     }
 
-    private ArgumentMatcher<Set<MembershipEntity>> verifyMembershipsToAdd() {
+    private ArgumentMatcher<Set<MembershipEntity>> verifyMembershipsToAdd1() {
         return memberships -> {
             assertEquals(1, memberships.size());
             MembershipEntity entity = memberships.iterator().next();
@@ -94,11 +136,29 @@ public class JoinServiceTest {
         };
     }
 
-    private ArgumentMatcher<Set<PermissionEntity>> verifyPermissionsToAdd() {
+    private ArgumentMatcher<Set<PermissionEntity>> verifyPermissionsToAdd1() {
         return permissions -> {
             assertEquals(2, permissions.size());
             return permissions.contains(permissionEntity("B", USER_1, Permission.ADMIN))
                     && permissions.contains(permissionEntity("D", USER_1, Permission.VIEW_MEMBERS));
         };
     }
+
+    private ArgumentMatcher<Set<MembershipEntity>> verifyMembershipsToAdd2() {
+        return memberships -> {
+            assertEquals(1, memberships.size());
+            MembershipEntity entity = memberships.iterator().next();
+            assertEquals("C", entity.getGroupId());
+            assertEquals(USER_2, entity.getUserId());
+            return true;
+        };
+    }
+
+    private ArgumentMatcher<Set<PermissionEntity>> verifyPermissionsToAdd2() {
+        return permissions -> {
+            assertEquals(2, permissions.size());
+            return permissions.contains(permissionEntity("C", USER_2, Permission.ADMIN))
+                    && permissions.contains(permissionEntity("D", USER_2, Permission.VIEW_MEMBERS));
+        };
+    }
 }

gms/src/test/java/it/inaf/ia2/gms/service/PermissionsServiceTest.java

@@ -23,6 +23,9 @@ import org.mockito.junit.MockitoJUnitRunner;
 @RunWith(MockitoJUnitRunner.class)
 public class PermissionsServiceTest {
 
+    private static final String ADMIN_ID = "ADMIN_ID";
+    private static final String USER_ID = "USER_ID";
+
     @Mock
     private PermissionsDAO permissionsDAO;
 
@@ -42,12 +45,12 @@ public class PermissionsServiceTest {
         existingEntity.setGroupId("ROOT");
         existingEntity.setPermission(Permission.VIEW_MEMBERS);
 
-        when(permissionsDAO.findPermissionEntity(eq("ROOT"), eq("user_id")))
+        when(permissionsDAO.findPermissionEntity(eq("ROOT"), eq(USER_ID)))
                 .thenReturn(Optional.of(existingEntity));
 
         when(permissionsDAO.createOrUpdatePermission(any())).thenAnswer(invocation -> invocation.getArgument(0));
 
-        PermissionEntity result = permissionsService.addPermission(root, "user_id", Permission.ADMIN);
+        PermissionEntity result = permissionsService.addPermission(root, USER_ID, Permission.ADMIN, ADMIN_ID);
 
         ArgumentCaptor<PermissionEntity> entityCaptor = ArgumentCaptor.forClass(PermissionEntity.class);
         verify(permissionsDAO, times(1)).createOrUpdatePermission(entityCaptor.capture());
@@ -65,10 +68,10 @@ public class PermissionsServiceTest {
         existingEntity.setGroupId("ROOT");
         existingEntity.setPermission(Permission.MANAGE_MEMBERS);
 
-        when(permissionsDAO.findPermissionEntity(eq("ROOT"), eq("user_id")))
+        when(permissionsDAO.findPermissionEntity(eq("ROOT"), eq(USER_ID)))
                 .thenReturn(Optional.of(existingEntity));
 
-        PermissionEntity result = permissionsService.addPermission(root, "user_id", Permission.VIEW_MEMBERS);
+        PermissionEntity result = permissionsService.addPermission(root, USER_ID, Permission.VIEW_MEMBERS, ADMIN_ID);
 
         verify(permissionsDAO, never()).createOrUpdatePermission(any());
         assertEquals(Permission.MANAGE_MEMBERS, result.getPermission());
@@ -84,10 +87,10 @@ public class PermissionsServiceTest {
         existingEntity.setGroupId("ROOT");
         existingEntity.setPermission(Permission.VIEW_MEMBERS);
 
-        when(permissionsDAO.findPermissionEntity(eq("ROOT"), eq("user_id")))
+        when(permissionsDAO.findPermissionEntity(eq("ROOT"), eq(USER_ID)))
                 .thenReturn(Optional.of(existingEntity));
 
-        PermissionEntity result = permissionsService.addPermission(root, "user_id", Permission.VIEW_MEMBERS);
+        PermissionEntity result = permissionsService.addPermission(root, USER_ID, Permission.VIEW_MEMBERS, ADMIN_ID);
 
         verify(permissionsDAO, never()).createOrUpdatePermission(any());
         assertEquals(Permission.VIEW_MEMBERS, result.getPermission());

gms/src/test/java/it/inaf/ia2/gms/service/SearchServiceTest.java

@@ -12,6 +12,7 @@ import it.inaf.ia2.gms.persistence.PermissionsDAO;
 import it.inaf.ia2.gms.persistence.model.GroupEntity;
 import it.inaf.ia2.gms.persistence.model.PermissionEntity;
 import it.inaf.ia2.gms.authn.RapClient;
+import it.inaf.ia2.gms.model.request.GenericSearchRequest;
 import it.inaf.ia2.rap.data.Identity;
 import it.inaf.ia2.rap.data.IdentityType;
 import it.inaf.ia2.rap.data.RapUser;
@@ -118,7 +119,10 @@ public class SearchServiceTest {
         when(permissionsDAO.findUserPermissions(any())).thenReturn(
                 Collections.singletonList(permission));
 
-        PaginatedData<SearchResponseItem> response = searchService.search("foo", "manager_id", 1, 10);
+        GenericSearchRequest searchRequest = new GenericSearchRequest();
+        searchRequest.setQuery("foo");
+
+        PaginatedData<SearchResponseItem> response = searchService.search(searchRequest, "manager_id");
 
         assertEquals(2, response.getTotalItems());