Join implementation changes

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

+package it.inaf.ia2.gms.persistence;
+
+import it.inaf.ia2.gms.DataSourceConfig;
+import it.inaf.ia2.gms.model.Permission;
+import it.inaf.ia2.gms.persistence.model.GroupEntity;
+import it.inaf.ia2.gms.persistence.model.MembershipEntity;
+import it.inaf.ia2.gms.persistence.model.PermissionEntity;
+import java.util.HashSet;
+import java.util.Set;
+import javax.sql.DataSource;
+import static org.junit.Assert.assertEquals;
+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 JoinDAOTest {
+
+    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;
+    private PermissionsDAO permissionsDAO;
+    private JoinDAO joinDAO;
+
+    @Before
+    public void setUp() {
+        groupsDAO = new GroupsDAO(dataSource);
+        membershipsDAO = new MembershipsDAO(dataSource);
+        permissionsDAO = new PermissionsDAO(dataSource);
+        joinDAO = new JoinDAO(dataSource);
+    }
+
+    @Test
+    public void testJoin() {
+
+        groupsDAO.createGroup(groupEntity("A"));
+        groupsDAO.createGroup(groupEntity("B"));
+
+        permissionsDAO.createOrUpdatePermission(permissionEntity(USER_1, "A", Permission.VIEW_MEMBERS));
+        permissionsDAO.createOrUpdatePermission(permissionEntity(USER_1, "B", Permission.VIEW_MEMBERS));
+        permissionsDAO.createOrUpdatePermission(permissionEntity(USER_2, "A", Permission.ADMIN));
+
+        membershipsDAO.addMember(membershipEntity(USER_2, "A"));
+
+        Set<MembershipEntity> membershipsToAdd = new HashSet<>();
+        membershipsToAdd.add(membershipEntity(USER_1, "A"));
+
+        Set<PermissionEntity> permissionsToAdd = new HashSet<>();
+        permissionsToAdd.add(permissionEntity(USER_1, "A", Permission.ADMIN));
+
+        assertEquals(1, membershipsDAO.getUserMemberships(USER_2).size());
+        assertEquals(2, permissionsDAO.findUserPermissions(USER_1).size());
+        assertEquals(1, permissionsDAO.findUserPermissions(USER_2).size());
+
+        joinDAO.join(membershipsToAdd, permissionsToAdd, USER_2);
+
+        assertTrue(membershipsDAO.getUserMemberships(USER_2).isEmpty());
+        assertTrue(permissionsDAO.findUserPermissions(USER_2).isEmpty());
+        assertEquals(2, permissionsDAO.findUserPermissions(USER_1).size());
+        assertTrue(permissionsDAO.findUserPermissions(USER_1)
+                .contains(permissionEntity(USER_1, "A", Permission.ADMIN)));
+        assertEquals(1, membershipsDAO.getUserMemberships(USER_1).size());
+    }
+
+    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;
+    }
+
+    private PermissionEntity permissionEntity(String userId, String groupId, Permission permission) {
+        PermissionEntity permissionEntity = new PermissionEntity();
+        permissionEntity.setGroupId(groupId);
+        permissionEntity.setUserId(userId);
+        permissionEntity.setPermission(permission);
+        permissionEntity.setGroupPath(groupId);
+        return permissionEntity;
+    }
+}

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

+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.MembershipsDAO;
+import it.inaf.ia2.gms.persistence.PermissionsDAO;
+import it.inaf.ia2.gms.persistence.model.GroupEntity;
+import it.inaf.ia2.gms.persistence.model.MembershipEntity;
+import it.inaf.ia2.gms.persistence.model.PermissionEntity;
+import java.util.Arrays;
+import java.util.Set;
+import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentMatcher;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
+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 JoinServiceTest {
+
+    private static final String USER_1 = "user-1";
+    private static final String USER_2 = "user-2";
+
+    @Mock
+    private MembershipsDAO membershipsDAO;
+
+    @Mock
+    private PermissionsDAO permissionsDAO;
+
+    @Mock
+    private JoinDAO joinDAO;
+
+    @InjectMocks
+    private JoinService joinService;
+
+    @Test
+    public void testJoin() {
+
+        when(membershipsDAO.getUserMemberships(eq(USER_1)))
+                .thenReturn(Arrays.asList(groupEntity("A")));
+
+        when(membershipsDAO.getUserMemberships(eq(USER_2)))
+                .thenReturn(Arrays.asList(groupEntity("A"), groupEntity("B")));
+
+        when(permissionsDAO.findUserPermissions(eq(USER_1)))
+                .thenReturn(Arrays.asList(
+                        permissionEntity("A", USER_1, Permission.ADMIN),
+                        permissionEntity("B", USER_1, Permission.VIEW_MEMBERS),
+                        permissionEntity("C", USER_1, Permission.MANAGE_MEMBERS)
+                ));
+
+        when(permissionsDAO.findUserPermissions(eq(USER_2)))
+                .thenReturn(Arrays.asList(
+                        permissionEntity("A", USER_2, Permission.VIEW_MEMBERS),
+                        permissionEntity("B", USER_2, Permission.ADMIN),
+                        permissionEntity("C", USER_2, Permission.MANAGE_MEMBERS),
+                        permissionEntity("D", USER_2, Permission.VIEW_MEMBERS)
+                ));
+
+        joinService.join(USER_1, USER_2);
+
+        verify(joinDAO, times(1)).join(argThat(verifyMembershipsToAdd()),
+                argThat(verifyPermissionsToAdd()), eq(USER_2));
+    }
+
+    private GroupEntity groupEntity(String groupId) {
+        GroupEntity group = new GroupEntity();
+        group.setId(groupId);
+        return group;
+    }
+
+    private PermissionEntity permissionEntity(String groupId, String userId, Permission permission) {
+        PermissionEntity permissionEntity = new PermissionEntity();
+        permissionEntity.setGroupId(groupId);
+        permissionEntity.setUserId(userId);
+        permissionEntity.setPermission(permission);
+        return permissionEntity;
+    }
+
+    private ArgumentMatcher<Set<MembershipEntity>> verifyMembershipsToAdd() {
+        return memberships -> {
+            assertEquals(1, memberships.size());
+            MembershipEntity entity = memberships.iterator().next();
+            assertEquals("B", entity.getGroupId());
+            assertEquals(USER_1, entity.getUserId());
+            return true;
+        };
+    }
+
+    private ArgumentMatcher<Set<PermissionEntity>> verifyPermissionsToAdd() {
+        return permissions -> {
+            assertEquals(2, permissions.size());
+            return permissions.contains(permissionEntity("B", USER_1, Permission.ADMIN))
+                    && permissions.contains(permissionEntity("D", USER_1, Permission.VIEW_MEMBERS));
+        };
+    }
+}