wamblee.org Git - utils/blob - security/src/test/java/org/wamblee/usermgt/InMemoryGroupSetTest.java

   1 /*
   2  * Copyright 2005 the original author or authors.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.wamblee.usermgt;
  18
  19 import java.sql.SQLException;
  20 import java.util.Set;
  21
  22 import org.wamblee.persistence.hibernate.HibernateMappingFiles;
  23 import org.wamblee.test.spring.SpringTestCase;
  24 import org.wamblee.test.spring.SpringConfigFiles;
  25
  26 /**
  27  * Tests the inmemory group set. Intended to be subclassed for other
  28  * implementations of group set.
  29  */
  30 public class InMemoryGroupSetTest extends SpringTestCase {
  31
  32     protected GroupSet _groups;
  33
  34     public InMemoryGroupSetTest() {
  35         super(SpringConfigFiles.class, HibernateMappingFiles.class);
  36     }
  37
  38     protected InMemoryGroupSetTest(Class<? extends SpringConfigFiles> aSprings,
  39             Class<? extends HibernateMappingFiles> aMappings) {
  40         super(aSprings, aMappings);
  41     }
  42
  43     /**
  44      * This method must be overriden in subclasses.
  45      * @return New group set object.
  46      */
  47     protected GroupSet createGroupSet() {
  48         return new InMemoryGroupSet();
  49     }
  50
  51     /* (non-Javadoc)
  52      * @see org.wamblee.test.SpringTestCase#setUp()
  53      */
  54     @Override
  55     protected void setUp() throws Exception {
  56         super.setUp();
  57         _groups = createGroupSet();
  58         checkGroupCount(0);
  59     }
  60
  61
  62
  63     /**
  64      * Additional check to be implemented by a subclass.
  65      * @param aGroup Group to check for existence.
  66      */
  67     protected void checkGroupExists(String aGroup) throws SQLException {
  68         // Empty
  69     }
  70
  71     /**
  72      * Additional check to be implemented by a subclass.
  73      * @param aGroup Group to check for non-existence.
  74      */
  75     protected void checkGroupNotExists(String aGroup) throws SQLException {
  76         // Empty
  77     }
  78
  79     /**
  80      * Additional check to be implemented by a subclass.
  81      * @param aSize Expected number of groups.
  82      */
  83     protected void checkGroupCount(int aSize) throws SQLException {
  84         assertEquals(aSize, _groups.size());
  85     }
  86
  87     /**
  88      * Adds a group and verifies that the group is added using
  89      * find(), list(),  and contains().
  90      *
  91      */
  92     public void testAdd() throws SQLException {
  93        Group group = new Group("group1");
  94        assertTrue(  _groups.add(group) );
  95        checkGroupExists(group.getName());
  96        checkGroupCount(1);
  97        Group group2 = _groups.find("group1");
  98        assertNotNull(group2);
  99        assertEquals(group.getName(), group2.getName());
 100        Set<Group> set = _groups.list();
 101        assertEquals(1, set.size());
 102        assertTrue(set.contains(group));
 103     }
 104
 105     /**
 106      * Tries to find a non-existing group. Verifies that null is
 107      * returned.
 108      *
 109      */
 110     public void testFindUnknownGroup() throws SQLException {
 111        Group group1 = new Group("group1");
 112        Group group2 = new Group("group2");
 113        _groups.add(group1);
 114        _groups.add(group2);
 115        checkGroupExists(group1.getName());
 116        checkGroupExists(group2.getName());
 117
 118        assertNull( _groups.find("group3") );
 119        checkGroupNotExists("group3");
 120     }
 121
 122     /**
 123      * Adds duplicate group. Verifies that the existing group is left untouched.
 124      */
 125     public void testAddDuplicateGroup() throws SQLException {
 126        Group group1 = new Group("group1");
 127        _groups.add(group1);
 128
 129        assertEquals(1, _groups.list().size());
 130        assertTrue(_groups.contains(group1));
 131        group1 = new Group("group1");
 132        assertFalse(_groups.add(group1));
 133        assertEquals(1, _groups.list().size());
 134
 135        checkGroupExists(group1.getName());
 136        checkGroupCount(1);
 137     }
 138
 139     /**
 140      * Removes a group. Verifies that the group is
 141      * removed and the return value is true.
 142      *
 143      */
 144     public void testRemoveGroup() throws SQLException {
 145         Group group1 = new Group("group1");
 146         _groups.add(group1);
 147         assertTrue(_groups.contains(group1));
 148         checkGroupCount(1);
 149
 150         assertTrue(_groups.remove(group1));
 151         assertFalse(_groups.contains(group1));
 152         assertNull(_groups.find(group1.getName()));
 153         assertEquals(0, _groups.list().size());
 154         checkGroupCount(0);
 155     }
 156
 157     /**
 158      * Removes a non-existing group. Verifies that no groups are
 159      * removed an that the return value is true.
 160      *
 161      */
 162     public void testRemoveNonExistingGroup() throws SQLException {
 163         Group group1 = new Group("group1");
 164         _groups.add(group1);
 165         checkGroupCount(1);
 166         Group nonExistingGroup = new Group("group2");
 167         nonExistingGroup.setPrimaryKey(new Long(1000));
 168         nonExistingGroup.setPersistedVersion(1000);
 169         assertFalse(_groups.remove(nonExistingGroup));
 170         assertTrue(_groups.contains(group1));
 171         assertEquals(1, _groups.list().size());
 172         checkGroupCount(1);
 173     }
 174
 175     /**
 176      * Adds a number of groups to the set and verifies that list()
 177      * returns them all.
 178      *
 179      */
 180     public void testList() throws SQLException {
 181         Group group1 = new Group("group1");
 182         Group group2 = new Group("group2");
 183         Group group3 = new Group("group3");
 184         assertTrue(_groups.add(group1));
 185         assertTrue(_groups.add(group2));
 186         assertTrue(_groups.add(group3));
 187
 188         checkGroupExists(group1.getName());
 189         checkGroupExists(group2.getName());
 190         checkGroupExists(group3.getName());
 191
 192         Set<Group> set = _groups.list();
 193         assertTrue(set.contains(group1));
 194         assertTrue(set.contains(group2));
 195         assertTrue(set.contains(group3));
 196
 197         checkGroupCount(3);
 198     }
 199 }