@NotNull @Override public User perform() throws RepositoryException { User user = userManagerDelegate.createUser(userID, password, principal, intermediatePath); return UserDelegator.wrap(sessionDelegate, user); } });
@Override public User createUser(String userID, String password, Principal principal, @Nullable String intermediatePath) throws RepositoryException { try { return wrap(dlg.createUser(userID, password, principal, intermediatePath)); } finally { autosave(); } }
@Override protected void setUp() throws Exception { super.setUp(); user2 = userMgr.createUser("user2", "pw"); superuser.save(); }
private User createUser(String uid, String pw) throws RepositoryException, NotExecutableException { User u = userMgr.createUser(uid, pw); save(superuser); return u; }
public void testPasswordInContent() throws RepositoryException { testUser = userManager.createUser(testId, TEST_PW); superuser.save(); Node userNode = superuser.getNode(testUser.getPath()); String pwPropertyName = null; // EXERCISE: fill in Property pwProperty = userNode.getProperty(pwPropertyName); // EXERCISE: explain why the password property doesn't contain the 'pw' string assertFalse(TEST_PW.equals(pwProperty.getString())); }
@Test public void testCommitFailedRevertChanges() throws RepositoryException { User u = mgr.createUser("u", "u"); try { User u2 = mgr.createUser("u", "u"); fail(); } catch (RepositoryException e) { // success assertFalse(root.hasPendingChanges()); } }
public void testGetAuthorizable() throws RepositoryException { testUser = userManager.createUser("testUser", null, new PrincipalImpl("testPrincipal"), null); testGroup = userManager.createGroup("testGroup", new PrincipalImpl("testGroupPrincipal"), null); superuser.save(); // EXERCISE: use all methods provided on UserManager interface to retrieve a given user/group. // - lookup by id // - lookup by path // - lookup by principal // - lookup by id + class } }
private Authorizable createAuthorizable(boolean createGroup, @Nullable String intermediatePath) throws RepositoryException { String id = UUID.randomUUID().toString(); if (createGroup) { return getUserManager(root).createGroup(id, new PrincipalImpl(id), intermediatePath); } else { return getUserManager(root).createUser(id, null, new PrincipalImpl(id), intermediatePath); } }
@Override public void before() throws Exception { super.before(); String uid = "u" + UUID.randomUUID(); user = (UserImpl) getUserManager(root).createUser(uid, uid); root.commit(); impersonation = new ImpersonationImpl(user); }
private String getYetAnotherID() throws RepositoryException, NotExecutableException { if (otherUID2 == null) { // create a third user Principal p = getTestPrincipal(); otherUID2 = userMgr.createUser(p.getName(), buildPassword(p)).getID(); save(superuser); } return otherUID2; }
public void testGetCredentials() throws RepositoryException { testUser = userManager.createUser(testId, TEST_PW); Credentials creds = testUser.getCredentials(); // EXERCISE fix the expectation Credentials expected = null; assertEquals(expected, creds); // EXERCISE : complete and explain the expected behavior getHelper().getRepository().login(creds).logout(); }
@Test public void testAuthorizableNodeName() throws RepositoryException { testUser = userManager.createUser("test/:User", null); String nodeName = Text.getName(testUser.getPath()); String expectedNodeName = null; // EXERCISE : fill in the expected value assertEquals(expectedNodeName, nodeName); }
@Test public void testCreateUserWithPath() throws Exception { User user = getUserManager(root).createUser(id, "pw", new PrincipalImpl(id), "a/b"); root.commit(); assertNodeName(user, "a/b"); }
@Test public void testCreateRemoveUser() throws RepositoryException { User u = mgr.createUser("u", "u"); assertFalse(root.hasPendingChanges()); u.remove(); assertFalse(root.hasPendingChanges()); }
@Test public void testMemberAdded() throws Exception { testUser01 = getUserManager(root).createUser(TEST_USER_PREFIX + "01", ""); testGroup.addMember(testUser01); assertTrue(groupAction.onMemberAddedCalled); assertEquals(testGroup, groupAction.group); assertEquals(testUser01, groupAction.member); }
protected void setupAuthorizables() throws RepositoryException { for (JackrabbitSession s : writeSessions) { UserManager userManager = s.getUserManager(); User user = userManager.createUser(userId, userId); Group group = userManager.createGroup("group1"); group.addMember(user); Group group2 = userManager.createGroup("group2"); group2.addMember(user); s.save(); } }
@Test public void testActionIsCalled() throws Exception { user = getUserManager(root).createUser("testUser", "testUser12345"); root.commit(); assertEquals(1, testAction.onCreateCalled); user.changePassword("pW12345678"); assertEquals(1, testAction.onPasswordChangeCalled); user.changePassword("pW1234567890", "pW12345678"); assertEquals(2, testAction.onPasswordChangeCalled); }
@Test public void testImpersonation() throws Exception { User u = mgr.createUser("u", "u"); Impersonation imp = u.getImpersonation(); Principal p = mgr.getAuthorizable("anonymous").getPrincipal(); assertTrue(imp.grantImpersonation(p)); assertFalse(root.hasPendingChanges()); assertTrue(imp.revokeImpersonation(p)); assertFalse(root.hasPendingChanges()); }
@Test public void testPasswordValidationActionOnCreate() throws Exception { String hashed = PasswordUtil.buildPasswordHash("DWkej32H"); user = getUserManager(root).createUser("testuser", hashed); root.commit(); String pwValue = root.getTree(user.getPath()).getProperty(UserConstants.REP_PASSWORD).getValue(Type.STRING); assertFalse(PasswordUtil.isPlainTextPassword(pwValue)); assertTrue(PasswordUtil.isSame(pwValue, hashed)); }
@Test public void testAuthorizable() throws Exception { User u = mgr.createUser("u", "u"); u.setProperty("prop", getValueFactory().createValue("value")); assertFalse(root.hasPendingChanges()); u.setProperty("prop", new Value[] {getValueFactory().createValue(true)}); assertFalse(root.hasPendingChanges()); u.removeProperty("prop"); assertFalse(root.hasPendingChanges()); }