How to use

createUser

method

in

com.atlassian.user.UserManager

@Test
public void testHashingOnUser() throws EntityException
{
  UserManager userManager = getUserManager();
  int hash1 = userManager.createUser("user1").hashCode();
  int hash2 = userManager.getUser("user1").hashCode();
  int hash3 = userManager.createUser("user2").hashCode();
  assertEquals("User object's hashcode is incorrect", hash1, hash2);
  assertFalse("User object's hashcode is incorrect", hash2 == hash3);
}

@Override
public User createUser(String username) throws EntityException
{
  User user = underlyingUserManager.createUser(username);
  if (user != null)
    cacheUser(user.getName(), user);
  return user;
}

@Override
public User createUser(User userTemplate, Credential credential) throws EntityException
{
  User user = underlyingUserManager.createUser(userTemplate, credential);
  if (user != null)
    cacheUser(user.getName(), user);
  return user;
}

@Test
public void testNoMatchingUserQueryContextNoSearch() throws EntityException
{
  getUserManager().createUser("astroboy");
  getUserManager().createUser("atlas");
  QueryContext context = new DefaultQueryContext("dontrun");
  UserNameTermQuery query = new UserNameTermQuery("astro", TermQuery.SUBSTRING_CONTAINS);
  SearchResult searchResults = getEntityQueryParser().findUsers(query, context);
  assertNull(this.getClass().getName() + " is processing queries which are not meant for its repository",
      searchResults);
  searchResults = getEntityQueryParser().findUsers(query, new AllRepositoriesQueryContext());
  assertNotNull(this.getClass().getName() + "  is ignoring universal queries", searchResults);
}

protected void createTestUsers() throws EntityException
{
  List<DefaultUser> users = Arrays.asList(
    new DefaultUser("icarus", "icarus", "icarus@test.org"),
    new DefaultUser("orpheus", "orpheus", "orpheus@test.org"),
    new DefaultUser("bob", "bob", "bob@acme.org"),
    new DefaultUser("peter", "peter", "peter@acme.org")
  );
  for (DefaultUser user : users)
  {
    getUserManager().createUser(user, Credential.NONE);
  }
}

@Test
public final void testGetIdenticalUserEachTime() throws EntityException
{
  UserManager userManager = getUserManager();
  userManager.createUser("user");
  assertEquals("Users returned by getUser() should be equal",
    userManager.getUser("user"), userManager.getUser("user"));
}

@Test
public void testGetMemberNames() throws EntityException
{
  Group group = getGroupManager().createGroup("group");
  User user1 = getUserManager().createUser("user-a");
  User user2 = getUserManager().createUser("user-b");
  getGroupManager().addMembership(group, user2); // add membership in reverse order
  getGroupManager().addMembership(group, user1);
  Pager pager = getGroupManager().getMemberNames(group);
  assertEquals(2, pager.getCurrentPage().size());
  assertEquals("user-a", pager.getCurrentPage().get(0));
  assertEquals("user-b", pager.getCurrentPage().get(1));
}

@Test
public void testGetLocalMembersOrderedByUserName() throws EntityException
{
  Group group = getGroupManager().createGroup("group");
  User user1 = getUserManager().createUser("user-a");
  User user2 = getUserManager().createUser("user-b");
  getGroupManager().addMembership(group, user2); // add membership in reverse order
  getGroupManager().addMembership(group, user1);
  Pager pager = getGroupManager().getLocalMemberNames(group);
  assertEquals(2, pager.getCurrentPage().size());
  assertEquals("user-a", pager.getCurrentPage().get(0));
  assertEquals("user-b", pager.getCurrentPage().get(1));
}

private void addUser(UserManager userManager, GroupManager groupManager,
           String username, String fullName, String email, String password, String... groupNames) throws EntityException {
  User user = userManager.createUser(username);
  user.setFullName(fullName);
  user.setEmail(email);
  userManager.saveUser(user);
  userManager.alterPassword(user, password);
  for (String groupName : groupNames) {
    Group group = getOrCreateGroupIfAbsent(groupManager, groupName);
    groupManager.addMembership(group, user);
  }
}

@Test
public final void testSaveUser() throws EntityException
{
  UserManager userManager = getUserManager();
  assertTrue(userManager.isCreative());
  User user = userManager.createUser(new DefaultUser("zorro", "zorro", "zorro@mexican.rebellion.org"), Credential.NONE);
  User retrievedUser = userManager.getUser("zorro");
  assertEquals("userManager.saveUser(user) is not recording info: [" + userManager.getRepository(user).toString() + "]",
    "zorro@mexican.rebellion.org", retrievedUser.getEmail());
}

@Test
public final void testCreateUser() throws EntityException
{
  UserManager userManager = getUserManager();
  User user = userManager.createUser("user");
  assertNotNull(user);
  assertEquals(user, userManager.getUser("user"));
  assertEquals("user", user.getName());
}

@Test
public void testGetLocalMembers() throws EntityException
{
  Group group = getGroupManager().createGroup("group");
  User user = getUserManager().createUser("user");
  getGroupManager().addMembership(group, user);
  Pager pager = getGroupManager().getLocalMemberNames(group);
  assertEquals(1, pager.getCurrentPage().size());
}

@Test
public void testAddMembershipLocal() throws Exception
{
  Group group = getGroupManager().createGroup("group");
  User user = getUserManager().createUser("user");
  getGroupManager().addMembership(group, user);
  assertTrue(getGroupManager().hasMembership(group, user));
}

@Test
public void testGetLocalMemberNames() throws EntityException
{
  Group group = getGroupManager().createGroup("group");
  User user = getUserManager().createUser("user");
  getGroupManager().addMembership(group, user);
  Pager pager = getGroupManager().getMemberNames(group);
  assertEquals(1, PagerUtils.count(pager));
}

@Test
public void testRemoveLocalMembership() throws Exception
{
  Group group = getGroupManager().createGroup("group");
  User user = getUserManager().createUser("user");
  getGroupManager().addMembership(group, user);
  getGroupManager().removeMembership(group, user);
  assertFalse(getGroupManager().hasMembership(group, user));
}

@Test
public void testMembershipOfDefaultUser() throws Exception
{
  GroupManager groupManager = getGroupManager();
  UserManager userManager = getUserManager();
  Group group = groupManager.createGroup("group");
  User user = new DefaultUser("user", "Test User", "test@example.com");
  userManager.createUser(user, Credential.NONE);
  groupManager.addMembership(group, user);
  assertTrue(groupManager.hasMembership(group, user));
  groupManager.removeMembership(group, user);
  assertFalse(groupManager.hasMembership(group, user));
}

  @Test
  public void testChangeFullName() throws EntityException
  {
    DefaultUser user = new DefaultUser("user", "original name", "");
    User createdUser = getUserManager().createUser(user, Credential.NONE);

    DefaultUser updatedUser = new DefaultUser(createdUser);
    updatedUser.setFullName("another name");
    getUserManager().saveUser(updatedUser);

    User retrievedUser = getUserManager().getUser("user");
    assertNotNull(retrievedUser);
    assertEquals("another name", retrievedUser.getFullName());
  }
}

@Test
public final void testUpdateUser() throws Exception
{
  User createdUser = getUserManager().createUser(new DefaultUser("test", "", ""), Credential.NONE);
  DefaultUser updatedUser = new DefaultUser(createdUser);
  updatedUser.setFullName("Test User");
  updatedUser.setEmail("testuser@example.org");
  getUserManager().saveUser(updatedUser);
  User foundUser = getUserManager().getUser("test");
  assertEquals("test", foundUser.getName());
  assertEquals("Test User", foundUser.getFullName());
  assertEquals("testuser@example.org", foundUser.getEmail());
}

@Test
public void testRemoveGroup() throws EntityException
{
  Group group = getGroupManager().createGroup("test");
  getGroupManager().removeGroup(group);
  User user = getUserManager().createUser("fred");
  group = getGroupManager().createGroup("test");
  getGroupManager().addMembership(group, user);
  assertTrue(getGroupManager().hasMembership(group, user));
  getGroupManager().removeGroup(group);
  assertFalse(getGroupManager().hasMembership(group, user));
}

@Test
public final void testCreateUserWithProperties() throws Exception
{
  DefaultUser user = new DefaultUser("user", "testing 1 23", "spamOverload@somewhere");
  User createdUser = getUserManager().createUser(user, Credential.NONE);
  assertEquals(user.getName(), createdUser.getName());
  assertEquals(user.getFullName(), createdUser.getFullName());
  assertEquals(user.getEmail(), createdUser.getEmail());
  User retrievedUser = getUserManager().getUser(user.getName());
  assertEquals(user.getName(), retrievedUser.getName());
  assertEquals(user.getFullName(), retrievedUser.getFullName());
  assertEquals(user.getEmail(), retrievedUser.getEmail());
}