/*
 * Copyright 2005 the original author or authors.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */ 

package org.wamblee.usermgt;

import java.sql.SQLException;
import java.util.Set;

import junit.framework.TestCase;

import org.wamblee.persistence.hibernate.HibernateMappingFiles;
import org.wamblee.security.encryption.Md5HexMessageDigester;
import org.wamblee.test.spring.SpringTestCase;
import org.wamblee.test.spring.SpringConfigFiles;
import org.wamblee.usermgt.UserMgtException.Reason;

/**
 * Tests the inmemory user set. Intended to be subclassed for other
 * implementations of user set. 
 */
public class InMemoryUserSetTest extends TestCase {
    
    protected static final String PASSWORD = "abc123";
    
    private UserSet _users;
    private GroupSet _groups;
    
    private Group _group; 
    
    /**
     * This method must be overriden in subclasses. 
     * @return New user set object. 
     */
    protected UserSet createUserSet() { 
        return new InMemoryUserSet(   new RegexpNameValidator(RegexpNameValidator.PASSWORD_PATTERN, Reason.INVALID_PASSWORD, "Password must contain at least 6 characters"),
                new Md5HexMessageDigester()); 
    }
    
    /**
     * This method must be overriden in subclasses. 
     * @return New group set object. 
     */
    protected GroupSet createGroupSet() { 
        return new InMemoryGroupSet(); 
    }
    
    /* (non-Javadoc)
     * @see org.wamblee.test.SpringTestCase#setUp()
     */
    @Override
    protected void setUp() throws Exception {
        super.setUp();
        _users = createUserSet();
        _groups = createGroupSet(); 
        _group = new Group("group0");
        _groups.add(_group);
        checkUserCount(0);
        
    }
    
    protected UserSet getUsers() { 
        return _users; 
    }
    
    protected GroupSet getGroups() { 
        return _groups; 
    }
    
    protected Group createGroup(String aName) { 
        return new Group(aName);
    }
    
    protected User createUser(String aName, String aPassword, Group aGroup) throws UserMgtException { 
        return UsermgtTestUtils.createUser(aName, aPassword, aGroup);
    }
    
    protected void addUserToGroup(User aUser, Group aGroup) throws UserMgtException { 
        aUser.addGroup(aGroup); 
    }
    
    protected void removeUserFromGroup(User aUser, Group aGroup ) throws UserMgtException { 
        aUser.removeGroup(aGroup); 
    }
    
    /**
     * Additional check to be implemented by a subclass. 
     * @param aUser User to check for existence. 
     */
    protected void checkUserExists(String aUser) throws SQLException { 
        // Empty
    }
    
    /**
     * Additional check to be implemented by a subclass. 
     * @param aUser User to check for non-existence. 
     */
    protected void checkUserNotExists(String aUser) throws SQLException { 
        // Empty
    }
    
    /**
     * Additional check to be implemented by a subclass. 
     * @param aSize Expected number of users. 
     */
    protected void checkUserCount(int aSize) throws SQLException { 
        assertEquals(aSize, _users.size()); 
    }
    
    /**
     * Additional check to be implemented by a subclass. 
     * @param aUser User to check for existence. 
     */
    protected void checkGroupExists(String aUser) throws SQLException { 
        // Empty
    }
    
    /**
     * Additional check to be implemented by a subclass. 
     * @param aUser User to check for non-existence. 
     */
    protected void checkGroupNotExists(String aUser) throws SQLException { 
        // Empty
    }
    
    /**
     * Additional check to be implemented by a subclass. 
     * @param aSize Expected number of users. 
     */
    protected void checkGroupCount(int aSize) throws SQLException { 
        // Empty
    }
   
    
    /**
     * Adds a user and verifies that the user is added using 
     * find(), list(),  and contains().  
     *
     */
    public void testAdd() throws SQLException, UserMgtException { 
       User user = createUser("user1", PASSWORD, _group); 
       assertTrue(  _users.add(user) );
       checkUserExists(user.getName());
       checkUserCount(1);
       User user2 = _users.find("user1"); 
       assertNotNull(user2);
       assertEquals(user.getName(), user2.getName()); 
       Set<User> set = _users.list(); 
       assertEquals(1, set.size()); 
       assertTrue(set.contains(user));
    }
    
    /**
     * Tries to find a non-existing user. Verifies that null is
     * returned. 
     *
     */
    public void testFindUnknownUser() throws SQLException, UserMgtException { 
       User user1 = createUser("user1", PASSWORD, _group); 
       User user2 = createUser("user2", PASSWORD, _group);
       _users.add(user1); 
       _users.add(user2);
       checkUserExists(user1.getName()); 
       checkUserExists(user2.getName()); 
    
       assertNull( _users.find("user3") );
       checkUserNotExists("user3");
    }
    
    /**
     * Adds duplicate user. Verifies that the existing user is left untouched.  
     */
    public void testAddDuplicateUser() throws SQLException, UserMgtException { 
       User user1 = createUser("user1", PASSWORD, _group); 
       _users.add(user1); 
       
       assertEquals(1, _users.list().size()); 
       assertTrue(_users.contains(user1)); 
       user1 = createUser("user1", PASSWORD, _group); 
       assertFalse(_users.add(user1));
       assertEquals(1, _users.list().size());
       
       checkUserExists(user1.getName()); 
       checkUserCount(1); 
    }
    
    /**
     * Removes a user. Verifies that the user is 
     * removed and the return value is true. 
     *
     */
    public void testRemoveUser() throws SQLException, UserMgtException { 
        User user1 = createUser("user1", PASSWORD, _group); 
        _users.add(user1); 
        assertTrue(_users.contains(user1));
        checkUserCount(1);
        
        assertTrue(_users.remove(user1)); 
        assertFalse(_users.contains(user1)); 
        assertNull(_users.find(user1.getName()));
        assertEquals(0, _users.list().size());
        checkUserCount(0);
    }
  
    /**
     * Removes a non-existing user. Verifies that no users are
     * removed an that the return value is true. 
     *
     */
    public void testRemoveNonExistingUser() throws SQLException, UserMgtException { 
        User user1 = createUser("user1", PASSWORD, _group); 
        _users.add(user1); 
        checkUserCount(1);
        User nonExistingUser = createUser("user2", PASSWORD, _group);
        nonExistingUser.setPrimaryKey(new Long(1000));
        nonExistingUser.setPersistedVersion(10);
        assertFalse(_users.remove(nonExistingUser));
        assertTrue(_users.contains(user1)); 
        assertEquals(1, _users.list().size());
        checkUserCount(1); 
    }
    
    /**
     * Adds a number of users to the set and verifies that list() 
     * returns them all. 
     *
     */
    public void testList() throws SQLException, UserMgtException { 
        User user1 = createUser("user1", PASSWORD, _group); 
        User user2 = createUser("user2", PASSWORD, _group); 
        User user3 = createUser("user3", PASSWORD, _group); 
        assertTrue(_users.add(user1)); 
        assertTrue(_users.add(user2)); 
        assertTrue(_users.add(user3));
        
        checkUserExists(user1.getName()); 
        checkUserExists(user2.getName()); 
        checkUserExists(user3.getName()); 
        
        Set<User> set = _users.list(); 
        assertTrue(set.contains(user1)); 
        assertTrue(set.contains(user2)); 
        assertTrue(set.contains(user3));
        
        checkUserCount(3); 
    }
    
    /**
     * Adds several users to different groups and verifies that 
     * the correct users are returned when looking for users in 
     * different groups. 
     * @throws SQLException
     */
    public void testListByGroup() throws SQLException, UserMgtException {
        Group group1 = new Group("group1"); 
        Group group2 = new Group("group2");
        Group group3 = new Group("group3");
        _groups.add(group1); 
        _groups.add(group2); 
        _groups.add(group3);
        
        //           user1    user2    user3
        // group1     y         
        // group2     y       y           
        // group3     y       y           y
        
        User user1 = createUser("user1", PASSWORD, group1);
        user1.addGroup(group2); 
        user1.addGroup(group3);
        User user2 = createUser("user2", PASSWORD, group2); 
        user2.addGroup(group3); 
        User user3 = createUser("user3", PASSWORD, group3);
        _users.add(user1); 
        _users.add(user2); 
        _users.add(user3);
        
        checkUserExists(user1.getName());
        checkUserExists(user2.getName()); 
        checkUserExists(user3.getName()); 
        
        checkGroupExists(group1.getName());
        checkGroupExists(group2.getName()); 
        checkGroupExists(group3.getName()); 
        
        checkUserCount(3); 
        checkGroupCount(3+1); // also count the group that was created in the setUp().
        
        Set<User> list = _users.list(group1);
        assertTrue(list.contains(user1)); 
        assertEquals(1, list.size());
        
        list = _users.list(group2); 
        assertTrue(list.contains(user1));
        assertTrue(list.contains(user2));
        assertEquals(2, list.size());
        
        list = _users.list(group3); 
        assertTrue(list.contains(user1));
        assertTrue(list.contains(user2));
        assertTrue(list.contains(user3));
        assertEquals(3, list.size());
    }
}