org.keycloak.admin.client.resource.UsersResource Java Examples

@Test
public void defaultMaxResults() {
    GroupsResource groups = adminClient.realms().realm("test").groups();
    try (Response response = groups.add(GroupBuilder.create().name("test").build())) {
        String groupId = ApiUtil.getCreatedId(response);

        GroupResource group = groups.group(groupId);

        UsersResource users = adminClient.realms().realm("test").users();

        for (int i = 0; i < 110; i++) {
            try (Response r = users.create(UserBuilder.create().username("test-" + i).build())) {
                users.get(ApiUtil.getCreatedId(r)).joinGroup(groupId);
            }
        }

        assertEquals(100, group.members(null, null).size());
        assertEquals(100, group.members().size());
        assertEquals(105, group.members(0, 105).size());
        assertEquals(110, group.members(0, 1000).size());
        assertEquals(110, group.members(-1, -2).size());
    }
}
 

@Test
public void defaultMaxResults() {
    UsersResource users = adminClient.realms().realm("test").users();

    for (int i = 0; i < 110; i++) {
        users.create(UserBuilder.create().username("test-" + i).addAttribute("aName", "aValue").build()).close();
    }

    List<UserRepresentation> result = users.search("test", null, null);
    assertEquals(100, result.size());
    for (UserRepresentation user : result) {
        assertThat(user.getAttributes(), Matchers.notNullValue());
        assertThat(user.getAttributes().keySet(), Matchers.hasSize(1));
        assertThat(user.getAttributes(), Matchers.hasEntry(is("aName"), Matchers.contains("aValue")));
    }

    assertEquals(105, users.search("test", 0, 105).size());
    assertEquals(111, users.search("test", 0, 1000).size());
}
 

private void assertSingleUserSession(String realmName, String userName, String... expectedClientIds) {
    final UsersResource users = adminClient.realm(realmName).users();
    final ClientsResource clients = adminClient.realm(realmName).clients();

    UserRepresentation userRepresentation = users
      .search(userName).stream()
      .findFirst().get();

    List<UserSessionRepresentation> userSessions = users.get(userRepresentation.getId()).getUserSessions();
    assertThat(userSessions, hasSize(1));
    Map<String, String> clientSessions = userSessions.get(0).getClients();

    Set<String> clientIds = clientSessions.values().stream()
      .flatMap(c -> clients.findByClientId(c).stream())
      .map(ClientRepresentation::getClientId)
      .collect(Collectors.toSet());

    assertThat(clientIds, containsInAnyOrder(expectedClientIds));
}
 

@Test
public void testDeleteIdentityOnProviderRemoval() {
    String childUsername = "child";
    String childPassword = "password";
    String childIdp = CHILD_IDP;

    assertFederatedIdentity(childUsername, childPassword, childIdp);

    RealmResource realm = adminClient.realm(CHILD_IDP);
    UsersResource users = realm.users();
    List<UserRepresentation> search = users.search(childUsername);
    assertFalse(search.isEmpty());
    String userId = search.get(0).getId();
    List<FederatedIdentityRepresentation> identities = users.get(userId).getFederatedIdentity();
    assertFalse(identities.isEmpty());

    realm.identityProviders().get(PARENT_IDP).remove();
    
    identities = users.get(userId).getFederatedIdentity();
    assertTrue(identities.isEmpty());

    getTestingClient().server(CHILD_IDP).run(AccountLinkTest::checkEmptyFederatedIdentities);
}
 

@Before
public void configureTest() {
    super.configureTest();
    UsersResource users = testRealmResource().users();
    users.create(UserBuilder.create().username("user a").build());
    users.create(UserBuilder.create().username("user b").build());
    users.create(UserBuilder.create().username("user c").build());
}
 

public static UserAttributeUpdater forUserByUsername(RealmResource realm, String userName) {
    UsersResource users = realm.users();
    List<UserRepresentation> foundUsers = users.search(userName).stream()
      .filter(ur -> userName.equalsIgnoreCase(ur.getUsername()))
      .collect(Collectors.toList());
    assertThat(foundUsers, hasSize(1));
    UserResource userRes = users.get(foundUsers.get(0).getId());

    return new UserAttributeUpdater(userRes, realm);
}
 

public static Creator<UserResource> create(RealmResource realmResource, UserRepresentation rep) {
    final UsersResource users = realmResource.users();
    try (Response response = users.create(rep)) {
        String createdId = getCreatedId(response);
        final UserResource r = users.get(createdId);
        LOG.debugf("Created user ID %s", createdId);
        return new Creator(createdId, r, r::remove);
    }
}
 

@Test
public void testBriefRepresentationOnGroupMembers() {
    RealmResource realm = adminClient.realms().realm("test");
    String groupName = "brief-grouptest-group";
    String userName = "brief-grouptest-user";

    GroupsResource groups = realm.groups();
    try (Response response = groups.add(GroupBuilder.create().name(groupName).build())) {
        String groupId = ApiUtil.getCreatedId(response);

        GroupResource group = groups.group(groupId);

        UsersResource users = realm.users();

        UserRepresentation userRepresentation = UserBuilder.create()
                .username(userName)
                .addAttribute("myattribute", "myvalue")
                .build();

        Response r = users.create(userRepresentation);
        UserResource user = users.get(ApiUtil.getCreatedId(r));
        user.joinGroup(groupId);

        UserRepresentation defaultRepresentation = group.members(null, null).get(0);
        UserRepresentation fullRepresentation = group.members(null, null, false).get(0);
        UserRepresentation briefRepresentation = group.members(null, null, true).get(0);

        assertEquals("full group member representation includes attributes", fullRepresentation.getAttributes(), userRepresentation.getAttributes());
        assertEquals("default group member representation is full", defaultRepresentation.getAttributes(), userRepresentation.getAttributes());
        assertNull("brief group member representation omits attributes", briefRepresentation.getAttributes());

        group.remove();
        user.remove();
    }
}
 

@Test
public void defaultMaxResultsBrief() {
    UsersResource users = adminClient.realms().realm("test").users();

    for (int i = 0; i < 110; i++) {
        users.create(UserBuilder.create().username("test-" + i).addAttribute("aName", "aValue").build()).close();
    }

    List<UserRepresentation> result = users.search("test", null, null, true);
    assertEquals(100, result.size());
    for (UserRepresentation user : result) {
        assertThat(user.getAttributes(), Matchers.nullValue());
    }
}
 

public void setRequiredActionEnabled(String realm, String userId, String requiredAction, boolean enabled) {
    UsersResource usersResource = adminClient.realm(realm).users();

    UserResource userResource = usersResource.get(userId);
    UserRepresentation userRepresentation = userResource.toRepresentation();

    List<String> requiredActions = userRepresentation.getRequiredActions();
    if (enabled && !requiredActions.contains(requiredAction)) {
        requiredActions.add(requiredAction);
    } else if (!enabled && requiredActions.contains(requiredAction)) {
        requiredActions.remove(requiredAction);
    }

    userResource.update(userRepresentation);
}
 

@Before
public void init() {

  UserRepresentation userRepresentation = mock(UserRepresentation.class);
  RealmResource realmResource = mock(RealmResource.class);
  Keycloak keycloak = mock(Keycloak.class);

  PowerMockito.mockStatic(UserServiceImpl.class);
  UserService userService = mock(UserService.class);
  when(UserServiceImpl.getInstance()).thenReturn(userService);

  PowerMockito.mockStatic(KeyCloakConnectionProvider.class);
  when(KeyCloakConnectionProvider.getConnection()).thenReturn(keycloak);
  when(keycloak.realm(Mockito.anyString())).thenReturn(realmResource);

  UsersResource usersResource = mock(UsersResource.class);
  when(realmResource.users()).thenReturn(usersResource);

  UserResource userResource = mock(UserResource.class);
  when(usersResource.get(Mockito.any())).thenReturn(userResource);
  when(userResource.toRepresentation()).thenReturn(userRepresentation);
  when(userService.getUserById(Mockito.anyString())).thenReturn(user);
}
 

@Before
public void cleanupTestUserInConsumerRealm() {
    final UsersResource users = adminClient.realm(REALM_CONS_NAME).users();
    users.search(CONSUMER_CHOSEN_USERNAME).stream()
      .map(UserRepresentation::getId)
      .map(users::delete)
      .forEach(Response::close);
}
 

private void createSocialLink(String provider, UsersResource users, String userId) {
    String uuid = UUID.randomUUID().toString();

    FederatedIdentityRepresentation link = new FederatedIdentityRepresentation();
    link.setIdentityProvider(provider);
    link.setUserId(uuid);
    link.setUserName(uuid);
    users.get(userId).addFederatedIdentity(provider, link);
}
 

@Override
public UserRepresentation createUser(UsersResource users, UserRepresentation user) {
    // Add some additional attributes to user
    if (CREATE_OBJECTS) {
        Map<String, List<String>> attrs = new HashMap<>();
        attrs.put("attr1", Collections.singletonList("val1"));
        attrs.put("attr2", Collections.singletonList("val2"));
        user.setAttributes(attrs);
    }

    UserRepresentation userRep = super.createUser(users, user);

    // Add password
    if (CREATE_OBJECTS) {
        CredentialRepresentation password = new CredentialRepresentation();
        password.setType(CredentialRepresentation.PASSWORD);
        password.setValue("password");
        password.setTemporary(false);
        users.get(userRep.getId()).resetPassword(password);
    }

    // Add social link
    if (CREATE_SOCIAL_LINKS) {
        createSocialLink("facebook", users, userRep.getId());
    }

    return userRep;
}
 

@Test
public void testRequiredRole() throws Exception {
    performTests(() -> {
        login("jdoe", "jdoe");
        navigateToUserPremiumPage();
        assertWasNotDenied();

        RolesResource rolesResource = getClientResource(RESOURCE_SERVER_ID).roles();

        rolesResource.create(new RoleRepresentation("required-role", "", false));

        RolePolicyRepresentation policy = new RolePolicyRepresentation();

        policy.setName("Required Role Policy");
        policy.addRole("user_premium", false);
        policy.addRole("required-role", false);

        RolePoliciesResource rolePolicy = getAuthorizationResource().policies().role();

        rolePolicy.create(policy);
        policy = rolePolicy.findByName(policy.getName());

        updatePermissionPolicies("Premium Resource Permission", policy.getName());

        login("jdoe", "jdoe");
        navigateToUserPremiumPage();
        assertWasNotDenied();

        policy.getRoles().clear();
        policy.addRole("user_premium", false);
        policy.addRole("required-role", true);

        rolePolicy.findById(policy.getId()).update(policy);

        login("jdoe", "jdoe");
        navigateToUserPremiumPage();
        assertWasDenied();

        UsersResource users = realmsResouce().realm(REALM_NAME).users();
        UserRepresentation user = users.search("jdoe").get(0);

        RoleScopeResource roleScopeResource = users.get(user.getId()).roles().clientLevel(getClientResource(RESOURCE_SERVER_ID).toRepresentation().getId());
        RoleRepresentation requiredRole = rolesResource.get("required-role").toRepresentation();
        roleScopeResource.add(Arrays.asList(requiredRole));

        login("jdoe", "jdoe");
        navigateToUserPremiumPage();
        assertWasNotDenied();

        policy.getRoles().clear();
        policy.addRole("user_premium", false);
        policy.addRole("required-role", false);

        rolePolicy.findById(policy.getId()).update(policy);

        login("jdoe", "jdoe");
        navigateToUserPremiumPage();
        assertWasNotDenied();

        roleScopeResource.remove(Arrays.asList(requiredRole));

        login("jdoe", "jdoe");
        navigateToUserPremiumPage();
        assertWasNotDenied();
    });
}
 

public UsersResource usersResource() {
    return testRealmResource().users();
}
 

public static String userResourcePath(String userId) {
    URI uri = UriBuilder.fromUri("").path(RealmResource.class, "users").path(UsersResource.class, "get").build(userId);
    return uri.toString();
}
 

protected UsersResource users(ContainerInfo node) {
    return getAdminClientFor(node).realm(testRealmName).users();
}
 

@Test
public void testDeleteUser() {
    AuthorizationResource authorization = getClient().authorization();
    UserPolicyRepresentation representation = new UserPolicyRepresentation();

    representation.setName("Realm User Policy");
    representation.setDescription("description");
    representation.setDecisionStrategy(DecisionStrategy.CONSENSUS);
    representation.setLogic(Logic.NEGATIVE);
    representation.addUser("User D");
    representation.addUser("User E");
    representation.addUser("User F");

    assertCreated(authorization, representation);

    UsersResource users = getRealm().users();
    UserRepresentation user = users.search("User D").get(0);

    users.get(user.getId()).remove();

    representation = authorization.policies().user().findById(representation.getId()).toRepresentation();

    Assert.assertEquals(2, representation.getUsers().size());
    Assert.assertFalse(representation.getUsers().contains(user.getId()));

    user = users.search("User E").get(0);
    users.get(user.getId()).remove();

    representation = authorization.policies().user().findById(representation.getId()).toRepresentation();

    Assert.assertEquals(1, representation.getUsers().size());
    Assert.assertFalse(representation.getUsers().contains(user.getId()));

    user = users.search("User F").get(0);
    users.get(user.getId()).remove();

    try {
        authorization.policies().user().findById(representation.getId()).toRepresentation();
        fail("User policy should be removed");
    } catch (NotFoundException nfe) {
        // ignore
    }
}
 

public void create(String realm, UserRepresentation userToCreate) {
    RealmResource realmResource = realmRepository.loadRealm(realm);
    UsersResource usersResource = realmResource.users();

    Response response = usersResource.create(userToCreate);

    ResponseUtil.throwOnError(response);
}