* 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.security.authentication;
import junit.framework.TestCase;
import org.apache.log4j.Logger;
+import org.junit.Test;
import org.wamblee.security.authentication.Group;
import org.wamblee.security.authentication.GroupSet;
import org.wamblee.security.authentication.UserMgtException.Reason;
import org.wamblee.security.encryption.Md5HexMessageDigester;
-
+import java.util.List;
import java.util.Set;
/**
Reason.INVALID_GROUPNAME, "Invalid group"));
}
- protected User createUser(String aName, String aPassword, Group aGroup)
- throws UserMgtException {
- return UsermgtTestUtils.createUser(aName, aPassword, aGroup);
- }
+ // Construction
/**
* Constructs the admin, verify it contains no users and no groups.
assertEquals(0, admin.getGroupCount());
}
- /**
- * Creates a new group. Verifies the group is created correctly and that the
- * user is added.
- *
- */
- public void testCreateGroup() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- assertNotNull(group);
- assertEquals(GROUP1, group.getName());
-
- Set<Group> groups = admin.getGroups();
- assertEquals(1, groups.size());
- assertEquals(1, admin.getGroupCount());
- assertTrue(groups.contains(group));
+ // Basic user admin:
+ // void createUser(String aUser, String aPassword);
+ // boolean checkUser(String aUser);
+ // int getUserCount();
+ // List<String> getUsers();
+ // void renameUser(String aOldUserName, String aUserName);
+ // void removeUser(String aUser);
+ public void testCreateUser() {
+ assertFalse(admin.checkUser(USER1));
+ admin.createUser(USER1, PASS1);
+ assertTrue(admin.checkUser(USER1));
+ assertEquals(1, admin.getUserCount());
+ assertTrue(admin.checkPassword(USER1, PASS1));
+ assertFalse(admin.checkPassword(USER1, PASS2));
}
- private void createInvalidGroup(String aUsername) {
+ public void testCreateDuplicateUser() {
+ admin.createUser(USER1, PASS1);
+
try {
- admin.createGroup(aUsername);
+ admin.createUser(USER1, PASS2);
fail();
} catch (UserMgtException e) {
- assertEquals(UserMgtException.Reason.INVALID_GROUPNAME, e
- .getReason());
- assertEquals(0, admin.getGroupCount());
+ assertEquals(UserMgtException.Reason.DUPLICATE_USER, e.getReason());
+ assertEquals(1, admin.getUserCount());
}
}
/**
- * Creates a new group with an invalid name. Verifies that the appropriate
+ * Constructs users with invalid names. Verifies that the appropriate
* exception is thrown.
*
- * @throws UserMgtException
*/
- public void testCreateInvalidGroupName() throws UserMgtException {
- createInvalidGroup("");
- createInvalidGroup("0abc"); // should not start with digits
- createInvalidGroup("a b"); // should not contain spaces
- createInvalidGroup(" aa");
- createInvalidGroup("aa ");
- }
-
- /**
- * Creates a new group which conflicts with an existing one. Verifies that
- * the UserMgtException is thrown and that no group is added.
- *
- */
- public void testCreateDuplicateGroup() throws UserMgtException {
- admin.createGroup(GROUP1);
-
- try {
- admin.createGroup(GROUP1);
- } catch (UserMgtException e) {
- assertEquals(UserMgtException.Reason.DUPLICATE_GROUP, e.getReason());
- assertEquals(1, admin.getGroupCount());
-
- return;
- }
-
- fail();
+ public void testCreateInvalidUserName() throws UserMgtException {
+ createInvalidUser("");
+ createInvalidUser("0abc"); // should not start with digits
+ createInvalidUser("a b"); // should not contain spaces
+ createInvalidUser(" aa");
+ createInvalidUser("aa ");
}
- /**
- * Creates a new user. Verifies the user is created correctly and that the
- * user is added.
- *
- */
- public void testCreateUser() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- User user = admin.createUser(USER1, PASS1, group);
- assertNotNull(user);
- assertEquals(USER1, user.getName());
- user.checkPassword(PASS1);
-
- Set<User> users = admin.getUsers();
+ public void testRenameUser() {
+ admin.createUser(USER1, PASS1);
+ admin.renameUser(USER1, USER2);
+ List<String> users = admin.getUsers();
assertEquals(1, users.size());
- assertEquals(1, admin.getUserCount());
- assertTrue(users.contains(user));
+ assertTrue(users.contains(USER2));
}
- private void createInvalidUser(String aUsername, Group aGroup) {
+ public void testRenameUserInvalidUsername() {
+ admin.createUser(USER1, PASS1);
try {
- admin.createUser(aUsername, "pass", aGroup);
+ admin.renameUser(USER1, "a b");
fail();
} catch (UserMgtException e) {
- assertEquals(UserMgtException.Reason.INVALID_USERNAME, e
- .getReason());
- assertEquals(0, admin.getUserCount());
+ assertEquals(e.getReason(), Reason.INVALID_USERNAME);
}
}
- /**
- * Constructs users with invalid names. Verifies that the appropriate
- * exception is thrown.
- *
- */
- public void testCreateInvalidUserName() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- createInvalidUser("", group);
- createInvalidUser("0abc", group); // should not start with digits
- createInvalidUser("a b", group); // should not contain spaces
- createInvalidUser(" aa", group);
- createInvalidUser("aa ", group);
+ public void testRenameUserToItself() {
+ admin.createUser(USER1, PASS1);
+ admin.renameUser(USER1, USER1);
+ assertTrue(admin.checkUser(USER1));
}
- /**
- * Creates a new user which conflicts with an existing one. Verifies that
- * the UserMgtException is thrown and that no user is added.
- *
- */
- public void testCreateDuplicateUser() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- admin.createUser(USER1, PASS1, group);
-
+ public void testRenameUserDuplicateUser() {
+ admin.createUser(USER1, PASS1);
+ admin.createUser(USER2, PASS2);
try {
- admin.createUser(USER1, PASS2, group);
+ admin.renameUser(USER1, USER2);
fail();
} catch (UserMgtException e) {
- assertEquals(UserMgtException.Reason.DUPLICATE_USER, e.getReason());
- assertEquals(1, admin.getUserCount());
+ assertEquals(e.getReason(), Reason.DUPLICATE_USER);
}
}
- /**
- * Gets a known user by name. Verifies the correct user is obtained.
- * Verifies that null is returned when trying to obtain an unknown user.
- *
- */
- public void testGetUser() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- User user = admin.createUser(USER1, PASS1, group);
- User user2 = admin.getUser(USER1);
- assertTrue(user.equals(user2));
- assertNull(admin.getUser(USER2));
+ // Basic group admin:
+ // void createGroup(String aName);
+ // boolean checkGroup(String aGroup);
+ // int getGroupCount();
+ // List<String> getGroups();
+
+ public void testCreateGroup() {
+ admin.createGroup(GROUP1);
+ List<String> groups = admin.getGroups();
+ assertEquals(1, groups.size());
+ assertEquals(1, admin.getGroupCount());
+ assertTrue(groups.contains(GROUP1));
}
- /**
- * Gets a known group by name. Verifies the correct group is obtained.
- * Verifies that null is returned when the group is not known.
- *
- */
- public void testGetGroup() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- Group group2 = admin.getGroup(GROUP1);
- assertTrue(group.equals(group2));
- assertNull(admin.getGroup(GROUP2));
+ public void testCreateGroupInvalidName() {
+ createInvalidGroup("");
+ createInvalidGroup("0abc"); // should not start with digits
+ createInvalidGroup("a b"); // should not contain spaces
+ createInvalidGroup(" aa");
+ createInvalidGroup("aa ");
}
- /**
- * Adds a user to a group. Verifies that the user is added using several API
- * calls. Verifies that an exception occurs if the user is not already part
- * of the group.
- *
- */
- public void testAddUserToGroup() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- User user = admin.createUser(USER1, PASS1, group);
- Group group2 = admin.createGroup(GROUP2);
- assertTrue(user.isInGroup(group));
- assertFalse(user.isInGroup(group2));
- admin.addUserToGroup(user, group2);
- assertTrue(user.isInGroup(group));
- assertTrue(user.isInGroup(group2));
-
- Set<User> users = admin.getUsers(group2);
- assertNotNull(users);
- assertEquals(1, users.size());
- assertTrue(users.contains(user));
+ public void testCreateGroupDuplicateGroup() {
+ admin.createGroup(GROUP1);
try {
- admin.addUserToGroup(user, group);
+ admin.createGroup(GROUP1);
} catch (UserMgtException e) {
- assertEquals(UserMgtException.Reason.USER_ALREADY_IN_GROUP, e
- .getReason());
+ assertEquals(UserMgtException.Reason.DUPLICATE_GROUP, e.getReason());
+ assertEquals(1, admin.getGroupCount());
return;
}
fail();
}
- /**
- * Adds a user to a group where the user does not exist. Verifies that an
- * exception occurs.
- *
- */
- public void testAddUserToGroupUnknownUser() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- User user = createUser(USER1, PASS1, group);
+ // Passwords.
+ // boolean checkPassword(String aUser, String aPassword);
+ // boolean changePassword(String aUser, String aOldPassword, String
+ // aNewPassword);
+ // void setPassword(String aUser, String aPassword);
+
+ public void testChangePassword() {
+ admin.createUser(USER1, PASS1);
+ boolean changed = admin.changePassword(USER1, PASS1, PASS2);
+ assertTrue(changed);
+ assertTrue(admin.checkPassword(USER1, PASS2));
+ assertFalse(admin.checkPassword(USER1, PASS1));
+ }
+ public void testChangePasswordWrongPassword() {
+ admin.createUser(USER1, PASS1);
+ boolean changed = admin.changePassword(USER1, PASS2, PASS1);
+ assertFalse(changed);
+ assertFalse(admin.checkPassword(USER1, PASS2));
+ assertTrue(admin.checkPassword(USER1, PASS1));
+ }
+
+ public void testChangePasswordUnknownUser() {
+ admin.createUser(USER1, PASS1);
try {
- admin.addUserToGroup(user, group);
+ boolean changed = admin.changePassword(USER1 + "unknown", PASS2,
+ PASS1);
} catch (UserMgtException e) {
- assertEquals(UserMgtException.Reason.UNKNOWN_USER, e.getReason());
-
- return;
+ assertEquals(e.getReason(), Reason.UNKNOWN_USER);
}
-
- fail();
}
- /**
- * Adds a user to a group where the user does not exist. Verifies that an
- * exception occurs.
- *
- */
- public void testAddUserToGroupUnknownGroup() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- User user = admin.createUser(USER1, PASS1, group);
- Group group2 = new Group(GROUP2);
+ public void testSetPassword() {
+ admin.createUser(USER1, PASS1);
+ admin.setPassword(USER1, PASS2);
+ assertTrue(admin.checkPassword(USER1, PASS2));
+ assertFalse(admin.checkPassword(USER1, PASS1));
+ }
+ public void testSetPasswordUnknownUser() {
+ admin.createUser(USER1, PASS1);
try {
- admin.addUserToGroup(user, group2);
+ admin.setPassword(USER1 + "unknown", PASS2);
} catch (UserMgtException e) {
- assertEquals(UserMgtException.Reason.UNKNOWN_GROUP, e.getReason());
-
- return;
+ assertEquals(e.getReason(), Reason.UNKNOWN_USER);
}
-
- fail();
}
- /**
- * Removes a user from a group. Verifies that the user is removed from the
- * group using several API calls. Verifies that an exception occurs if the
- * user not part of the group or if the user is only part of one group.
- *
- */
- public void testRemoveUserFromGroup() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
-
- User user = admin.createUser(USER1, PASS1, group);
- Group group2 = admin.createGroup(GROUP2);
- admin.addUserToGroup(user, group2);
+ // Group membership
+ // boolean isInGroup(String aUser, String aGroup);
+ // List<String> getUsers(String aGroup);
+ // void addUserToGroup(String aUser, String aGroup);
+ // void removeUserFromGroup(String aUser, String aGroup);}
- Set<Group> groups = user.getGroups();
- assertEquals(2, groups.size());
- assertTrue(groups.contains(group));
- assertTrue(groups.contains(group2));
-
- admin.removeUserFromGroup(user, group);
- groups = user.getGroups();
- assertEquals(1, groups.size());
- assertTrue(groups.contains(group2));
- assertFalse(groups.contains(group));
+ public void testAddUserToGroup() {
+ admin.createUser(USER1, PASS1);
+ assertFalse(admin.isInGroup(USER1, GROUP1));
+ admin.createGroup(GROUP1);
+ admin.addUserToGroup(USER1, GROUP1);
+ assertTrue(admin.isInGroup(USER1, GROUP1));
+ List<String> users = admin.getUsers(GROUP1);
+ assertEquals(1, users.size());
+ assertTrue(users.contains(USER1));
}
- /**
- * Removes a user from a group where the user is not known. Verifies that an
- * exception is thrown.
- *
- */
- public void testRemoveUserFromGroupUnknownUser() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- User user = createUser(USER1, GROUP1, group);
+ public void testMultipleGroups() {
+ admin.createUser(USER1, PASS1);
+ admin.createGroup(GROUP1);
+ admin.createGroup(GROUP2);
+ assertFalse(admin.isInGroup(USER1, GROUP1));
+ assertFalse(admin.isInGroup(USER1, GROUP2));
+ admin.addUserToGroup(USER1, GROUP1);
+ admin.addUserToGroup(USER1, GROUP2);
+ assertTrue(admin.isInGroup(USER1, GROUP1));
+ assertTrue(admin.isInGroup(USER1, GROUP2));
+ }
+ public void testAddUserToGroupUnknownUser() {
+ admin.createGroup(GROUP2);
try {
- admin.removeUserFromGroup(user, group);
+ admin.addUserToGroup(USER1, GROUP2);
} catch (UserMgtException e) {
- assertEquals(UserMgtException.Reason.UNKNOWN_USER, e.getReason());
+ assertEquals(e.getReason(), Reason.UNKNOWN_USER);
}
- }
- /**
- * Removes a user from a group where the group is not known. Verifies that
- * an exception is thrown.
- *
- */
- public void testRemoveUserFromGroupUnknownGroup() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- User user = admin.createUser(USER1, PASS1, group);
- Group group2 = new Group(GROUP2);
+ }
+ public void testAddUserToGroupUnknownGroup() {
+ admin.createUser(USER1, PASS1);
try {
- admin.removeUserFromGroup(user, group2);
+ admin.addUserToGroup(USER1, GROUP2);
} catch (UserMgtException e) {
- assertEquals(UserMgtException.Reason.UNKNOWN_GROUP, e.getReason());
+ assertEquals(e.getReason(), Reason.UNKNOWN_GROUP);
}
}
- /**
- * Removes a user from a group where the user is only part of one group.
- * Verifies that an exception is thrown.
- *
- */
- public void testRemoveUserFromGroupOnlyGroup() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- User user = admin.createUser(USER1, PASS1, group);
+ public void testRemoveUserFromGroup() {
+ admin.createUser(USER1, GROUP1);
+ admin.createGroup(GROUP1);
+ admin.addUserToGroup(USER1, GROUP1);
+ assertTrue(admin.isInGroup(USER1, GROUP1));
+ admin.removeUserFromGroup(USER1, GROUP1);
+ assertFalse(admin.isInGroup(USER1, GROUP1));
+ }
+ public void testRemoveUserFromGroupUserNotInGroup() {
+ admin.createUser(USER1, GROUP1);
+ admin.createGroup(GROUP1);
+ admin.createGroup(GROUP2);
+ admin.addUserToGroup(USER1, GROUP1);
try {
- admin.removeUserFromGroup(user, group);
+ admin.removeUserFromGroup(USER1, GROUP2);
+ fail();
} catch (UserMgtException e) {
- assertEquals(UserMgtException.Reason.USER_MUST_BE_IN_A_GROUP, e
- .getReason());
+ assertEquals(Reason.USER_NOT_IN_GROUP, e.getReason());
}
}
- /**
- * Gets the list of users and groups. Verifies that the correct suers and
- * groups are returned. Verifies also that the relations from user to group
- * are correct.
- *
- */
- public void testGetUsersAndGroups() throws UserMgtException {
- Group group1 = admin.createGroup(GROUP1);
- Group group2 = admin.createGroup(GROUP2);
-
- User user1 = admin.createUser(USER1, PASS1, group1);
- admin.addUserToGroup(user1, group2);
-
- User user2 = admin.createUser(USER2, PASS2, group2);
-
- Set<User> users = admin.getUsers();
- assertEquals(2, users.size());
- assertTrue(users.contains(user1));
- assertTrue(users.contains(user2));
-
- Set<Group> groups = admin.getGroups();
- assertEquals(2, groups.size());
- assertTrue(groups.contains(group1));
- assertTrue(groups.contains(group2));
-
- assertTrue(user1.isInGroup(group1));
- assertTrue(user1.isInGroup(group2));
- assertFalse(user2.isInGroup(group1));
- assertTrue(user2.isInGroup(group2));
-
- Set<Group> groups1 = user1.getGroups();
- assertEquals(2, groups1.size());
-
- Set<Group> groups2 = user2.getGroups();
- assertEquals(1, groups2.size());
- }
-
- /**
- * Renames a user. Verifies that the user is renamed. Verifies that
- * exceptions are thrown when an attempt is made to rename the user to
- * itself or to another existing user, or when the group does not exist.
- *
- */
- public void testRenameUser() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- User user1 = admin.createUser(USER1, PASS1, group);
- admin.renameUser(user1, USER2);
- assertEquals(USER2, user1.getName());
- assertEquals(user1, admin.getUser(USER2));
-
+ public void testRemoveUserFromGroupUnknowUser() {
+ admin.createGroup(GROUP1);
try {
- admin.renameUser(user1, USER1);
- } catch (UserMgtException e) {
- assertEquals(UserMgtException.Reason.DUPLICATE_USER, e.getReason());
-
- // do a trivial reanem
- try {
- admin.renameUser(user1, user1.getName());
- } catch (UserMgtException e2) {
- assertEquals(UserMgtException.Reason.TRIVIAL_RENAME, e2
- .getReason());
-
- return;
- }
-
+ admin.removeUserFromGroup(USER1, GROUP2);
fail();
+ } catch (UserMgtException e) {
+ assertEquals(Reason.UNKNOWN_USER, e.getReason());
}
-
- fail();
}
- /**
- * Renames a user to a user with an invalid username. Verifies that the
- * appropriate exception is thrown.
- *
- */
- public void testRenameUserInvalidUsername() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- User user1 = admin.createUser(USER1, PASS1, group);
-
+ public void testRemoveUserFromGroupUnknownGroup() {
+ admin.createUser(USER1, PASS1);
try {
- admin.renameUser(user1, USER2);
+ admin.removeUserFromGroup(USER1, GROUP2);
+ fail();
} catch (UserMgtException e) {
- assertEquals(e.getReason(), Reason.INVALID_USERNAME);
+ assertEquals(Reason.UNKNOWN_GROUP, e.getReason());
}
}
- /**
- * Renames a group. Verifies that the group is renamed. Verifies that
- * exceptions are thrown when an attempt is made to rename the group to
- * itself or to another existing group or when the group does not exist.
- *
- */
- public void testRenameGroup() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- admin.renameGroup(group, GROUP2);
- assertEquals(GROUP2, group.getName());
- assertEquals(group, admin.getGroup(GROUP2));
+ // void renameGroup(String aOldGroup, String aGroupName)
+ public void testRenameGroup() {
+ admin.createUser(USER1, PASS1);
admin.createGroup(GROUP1);
+ admin.addUserToGroup(USER1, GROUP1);
+ admin.renameGroup(GROUP1, GROUP2);
+ List<String> groups = admin.getGroups();
+ assertEquals(1, groups.size());
+ assertTrue(groups.contains(GROUP2));
+ assertTrue(admin.isInGroup(USER1, GROUP2));
+ assertFalse(admin.isInGroup(USER1, GROUP1));
+ }
+ public void testRenameGroupGroupNameInvalid() {
+ admin.createGroup(GROUP1);
try {
- admin.renameGroup(group, GROUP1);
- } catch (UserMgtException e) {
- assertEquals(UserMgtException.Reason.DUPLICATE_GROUP, e.getReason());
-
- // do a trivial reanem
- try {
- admin.renameGroup(group, group.getName());
- } catch (UserMgtException e2) {
- assertEquals(UserMgtException.Reason.TRIVIAL_RENAME, e2
- .getReason());
-
- return;
- }
-
+ admin.renameGroup(GROUP1, "a b");
fail();
-
- return;
+ } catch (UserMgtException e) {
+ assertEquals(Reason.INVALID_GROUPNAME, e.getReason());
}
-
- fail();
}
- /**
- * Renames a group to a group with an invalid name. Verifies that the
- * appropriate exception is thrown.
- *
- */
- public void testRenameGroupInvalidGroupname() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
-
+ public void testRenameGroupGroupAlreadyExists() {
+ admin.createGroup(GROUP1);
+ admin.createGroup(GROUP2);
try {
- admin.renameGroup(group, "a b");
+ admin.renameGroup(GROUP1, GROUP2);
+ fail();
} catch (UserMgtException e) {
- assertEquals(e.getReason(), Reason.INVALID_GROUPNAME);
+ assertEquals(Reason.DUPLICATE_GROUP, e.getReason());
}
}
- /**
- * Removes a user. Verifies that the user is removed. Verifies that the an
- * exception is thrown when the user does not exist.
- *
- */
- public void testRemoveUser() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- User user = admin.createUser(USER1, PASS1, group);
-
- assertEquals(1, admin.getUserCount());
- admin.removeUser(user);
- assertEquals(0, admin.getUserCount());
-
- admin.createUser(USER1, PASS1, group);
- assertEquals(1, admin.getUserCount());
+ // void removeGroup(String aGroup);
- User user2 = createUser(USER2, PASS2, group);
+ public void testRemoveGroup() {
+ admin.createGroup(GROUP1);
+ admin.removeGroup(GROUP1);
+ List<String> groups = admin.getGroups();
+ assertEquals(0, groups.size());
+ }
+ public void testRemoveGroupGroupDoesNotExist() {
try {
- admin.removeUser(user2);
+ admin.removeGroup(GROUP1);
+ fail();
} catch (UserMgtException e) {
- assertEquals(UserMgtException.Reason.UNKNOWN_USER, e.getReason());
+ assertEquals(e.getReason(), Reason.UNKNOWN_GROUP);
}
}
- /**
- * Removes a group. Verifies that the group is removed. Verifies that the an
- * exception is thrown when the group does not exist or if there are still
- * users in the group.
- *
- */
- public void testRemoveGroup() throws UserMgtException {
- Group group1 = admin.createGroup(GROUP1);
- assertEquals(1, admin.getGroupCount());
- admin.removeGroup(group1);
- assertEquals(0, admin.getGroupCount());
- group1 = admin.createGroup(GROUP1);
-
- admin.createUser(USER1, PASS1, group1);
+ public void testRemoveGroupButStillUsersInGroup() {
+ admin.createUser(USER1, PASS1);
+ admin.createGroup(GROUP1);
+ admin.addUserToGroup(USER1, GROUP1);
+ try {
+ admin.removeGroup(GROUP1);
+ } catch (UserMgtException e) {
+ assertEquals(e.getReason(), Reason.GROUP_STILL_OCCUPIED);
+ }
+ }
+ private void createInvalidGroup(String aUsername) {
try {
- admin.removeGroup(group1);
+ admin.createGroup(aUsername);
+ fail();
} catch (UserMgtException e) {
- assertEquals(UserMgtException.Reason.GROUP_STILL_OCCUPIED, e
+ assertEquals(UserMgtException.Reason.INVALID_GROUPNAME, e
.getReason());
-
- return;
+ assertEquals(0, admin.getGroupCount());
}
-
- fail();
}
- /**
- * Tries to remove an unknown group. Verifies that an exception is thrown.
- *
- */
- public void testRemoveGroupUnknownGroup() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- Group group2 = new Group(GROUP2);
-
+ private void createInvalidUser(String aUsername) {
try {
- admin.removeGroup(group2);
+ admin.createUser(aUsername, "pass");
+ fail();
} catch (UserMgtException e) {
- assertEquals(UserMgtException.Reason.UNKNOWN_GROUP, e.getReason());
+ assertEquals(UserMgtException.Reason.INVALID_USERNAME, e
+ .getReason());
+ assertEquals(0, admin.getUserCount());
}
}
/**
- * Changes the password, verifies that this succeeds.
+ * Gets the list of users and groups. Verifies that the correct suers and
+ * groups are returned. Verifies also that the relations from user to group
+ * are correct.
*
- * @throws UserMgtException
*/
- public void testChangePassword() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- User user = admin.createUser(USER1, PASS1, group);
- user.changePassword(PASS1, PASS2);
+ public void testGetUsersAndGroups() throws UserMgtException {
+ admin.createGroup(GROUP1);
+ admin.createGroup(GROUP2);
- // retrieve the user and verifies the password hasn't changed.
- User user2 = admin.getUser(USER1);
+ admin.createUser(USER1, PASS1);
+ admin.addUserToGroup(USER1, GROUP1);
+ admin.addUserToGroup(USER1, GROUP2);
- try {
- user2.checkPassword(PASS2);
- fail(); // password should not have changed already.
- } catch (UserMgtException e) {
- // ok.
- }
+ admin.createUser(USER2, PASS2);
+ admin.addUserToGroup(USER2, GROUP2);
- // now notify the admin of the change in the user
- admin.userModified(user);
+ List<String> users = admin.getUsers();
+ assertEquals(2, users.size());
+ assertTrue(users.contains(USER1));
+ assertTrue(users.contains(USER2));
- user2 = admin.getUser(USER1);
- user2.checkPassword(PASS2); // this time it should succeed.
+ List<String> groups = admin.getGroups();
+ assertEquals(2, groups.size());
+ assertTrue(groups.contains(GROUP1));
+ assertTrue(groups.contains(GROUP2));
+
+ assertTrue(admin.isInGroup(USER1, GROUP1));
+ assertTrue(admin.isInGroup(USER1, GROUP2));
+ assertFalse(admin.isInGroup(USER2, GROUP1));
+ assertTrue(admin.isInGroup(USER2, GROUP2));
+
+ List<String> groups1 = admin.getGroups(USER1);
+ assertEquals(2, groups1.size());
+
+ List<String> groups2 = admin.getGroups(USER2);
+ assertEquals(1, groups2.size());
}
/**
*
*/
public void testPerformanceFindUserByName() throws UserMgtException {
- Group group = admin.createGroup(GROUP1);
- admin.createUser(USER1, PASS1, group);
+ admin.createGroup(GROUP1);
+ admin.createUser(USER1, PASS1);
+ admin.addUserToGroup(USER1, GROUP1);
int n = 1000;
long time = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
- admin.getUser(USER1);
+ admin.checkUser(USER1);
}
LOGGER.info("Looked up a user " + n + " times in " +
git://wamblee.org / utils / blobdiff