UserGroupDAOTest.java

/*
 *  Copyright (C) 2007 - 2011 GeoSolutions S.A.S.
 *  http://www.geo-solutions.it
 * 
 *  GPLv3 + Classpath exception
 * 
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 * 
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 * 
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package it.geosolutions.geostore.core.dao;

import it.geosolutions.geostore.core.model.Category;
import it.geosolutions.geostore.core.model.SecurityRule;
import it.geosolutions.geostore.core.model.User;
import it.geosolutions.geostore.core.model.UserGroup;
import it.geosolutions.geostore.core.model.enums.Role;

import java.util.HashSet;
import java.util.Set;

import org.apache.log4j.Logger;
import org.junit.Test;

/**
 * Class UserGroupDAOTest.
 * 
 * @author Tobia di Pisa (tobia.dipisa at geo-solutions.it)
 * @author DamianoG
 * 
 */
public class UserGroupDAOTest extends BaseDAOTest {

    final private static Logger LOGGER = Logger.getLogger(UserGroupDAOTest.class);

    /**
     * @throws Exception
     */
    @Test
    public void testPersistUserGroup() throws Exception {

        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("Persisting UserGroup");
        }

        long securityId1;
        long securityId2;
        long userId1;
        long groupId2;
        User user2;

        //
        // PERSIST
        //
        {
            Category category = new Category();
            category.setName("MAP");

            categoryDAO.persist(category);

            assertEquals(1, categoryDAO.count(null));
            assertEquals(1, categoryDAO.findAll().size());

            Set<UserGroup> groups = new HashSet<UserGroup>();
            UserGroup g1 = new UserGroup();
            g1.setGroupName("GROUP1");
            UserGroup g2 = new UserGroup();
            g2.setGroupName("GROUP2");
            groups.add(g1);
            groups.add(g2);

            userGroupDAO.persist(g1);
            userGroupDAO.persist(g2);
            groupId2 = g2.getId();
            
            assertEquals(2, userGroupDAO.count(null));
            assertEquals(2, userGroupDAO.findAll().size());

            //Create User1, associate to him group1 and group2 and set an example security rule 
            User user1 = new User();
            user1.setGroups(groups);
            user1.setName("USER1_NAME");
            user1.setNewPassword("user");
            user1.setRole(Role.ADMIN);

            userDAO.persist(user1);
            userId1 = user1.getId();
            
            assertEquals(1, userDAO.findAll().size());
            assertEquals(1, userDAO.count(null));
            

            SecurityRule security = new SecurityRule();
            security.setCanRead(true);
            security.setCanWrite(true);
            //Why set both user and group? just for test? The Application shouldn't allows that... 
            security.setGroup(g1);
            security.setUser(user1);

            securityDAO.persist(security);
            securityId1 = security.getId();

            assertEquals(1, securityDAO.count(null));
            assertEquals(1, securityDAO.findAll().size());
            
            //Create User2, associate to him group2 and set an example security rule 
            user2 = new User();
            user2.setGroups(groups);
            user2.setName("USER2_NAME");
            user2.setNewPassword("user");
            user2.setRole(Role.USER);

            userDAO.persist(user2);
            
            assertEquals(2, userDAO.findAll().size());
            assertEquals(2, userDAO.count(null));
            

            SecurityRule security2 = new SecurityRule();
            security2.setCanRead(true);
            security2.setCanWrite(true);
            //Set a security rule just for the group (the GeoStore application logic creates another rule also for the owner user) 
            security2.setGroup(g2);

            securityDAO.persist(security2);
            securityId2 = security2.getId();

            assertEquals(2, securityDAO.count(null));
            assertEquals(2, securityDAO.findAll().size());

        }

        //
        // LOAD, REMOVE, CASCADING
        //
        {
            // USER REMOVAL, the cascading on security rules relation  will remove also the related rules.
            // The user is also the owner of the many2many relations with entity GROUP so the entry on that relation table is automatically deleted.
            User user1 = userDAO.find(userId1);
            userDAO.remove(user1);
            assertEquals(1, securityDAO.count(null));
            assertEquals(1, securityDAO.findAll().size());
            assertEquals(1, userDAO.findAll().size());
            assertEquals(1, userDAO.count(null));
            assertEquals(2, userGroupDAO.findAll().size());
            assertEquals(2, userGroupDAO.count(null));
            assertNull("SecurityRule not deleted", securityDAO.find(securityId1));
            assertNotNull("Group SecurityRule deleted... that's a mistake!", securityDAO.find(securityId2));
            
            // GROUP REMOVAL, being the entity USER the owner of the relation we should remove manually the entries in the relationship table
            // removing the group association to all user
            UserGroup group2 = userGroupDAO.find(groupId2);
            Set<User> users = group2.getUsers();
            assertEquals(1, users.size());
            for(User u : users){
                u.getGroups().remove(group2);
                userDAO.merge(u);
            }
            userGroupDAO.remove(group2);
            assertEquals(1, userGroupDAO.findAll().size());
            assertEquals(1, userGroupDAO.count(null));
            assertNull("Group SecurityRule not deleted", securityDAO.find(securityId2));
            userDAO.remove(user2);
        }

    }

}