JUnit-Test for the not-filter-bug

BugFilterWithNot.java

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;
import org.osiam.client.OsiamConnector;
import org.osiam.client.oauth.AccessToken;
import org.osiam.client.oauth.Scope;
import org.osiam.client.query.Query;
import org.osiam.client.query.QueryBuilder;
import org.osiam.resources.scim.Group;
import org.osiam.resources.scim.MemberRef;
import org.osiam.resources.scim.SCIMSearchResult;
import org.osiam.resources.scim.UpdateGroup;
import org.osiam.resources.scim.User;

public class BugFilterWithNot {
private static final String ADMIN_USER_NAME = "marissa";
private static final String ADMIN_USER_PASSWORD = "koala";

private static final String NAME_GROUP_ONE = "GroupOne";
private static final String NAME_GROUP_TWO = "GroupTwo";

private OsiamConnector connector;
private AccessToken accessToken;
private String testUserId;

@Before
public void setup(){
    connector = buildConnector();
    accessToken = getAccessToken();
    setupTestEnvironment();
}

private OsiamConnector buildConnector() {
    OsiamConnector connector = new OsiamConnector.Builder()
                                    .setEndpoint("http://localhost:8080/")
                                    .setClientId("example-client")
                                    .setClientSecret("secret")
                                .build();

    return connector;
}

private AccessToken getAccessToken() {
    return connector.retrieveAccessToken(ADMIN_USER_NAME, ADMIN_USER_PASSWORD, Scope.ALL);
}

private void setupTestEnvironment() {
    Group groupOne = addTestGroup(NAME_GROUP_ONE);
    Group groupTwo = addTestGroup(NAME_GROUP_TWO);

    QueryBuilder qb = new QueryBuilder();
    qb.filter("userName eq \"" + ADMIN_USER_NAME + "\"");

    testUserId = connector.searchUsers(qb.build(), accessToken).getResources().get(0).getId();

    addUserToGroup(groupOne.getId(), testUserId);
}

private void addUserToGroup(String groupId, String userId) {
    UpdateGroup updateGroup = new UpdateGroup.Builder()
                .addMember(userId)
            .build();

    connector.updateGroup(groupId, updateGroup, accessToken);
}

private Group addTestGroup(String groupName) {
    Group found = getGroupByName(groupName);
    if(found != null){
        return found;
    }

    Group group = new Group.Builder(groupName)
                    .build();

    return connector.createGroup(group, accessToken);
}

private Group getGroupByName(String groupName) {
    Query query = new QueryBuilder().filter("displayName eq \"" + groupName + "\"").build();

    SCIMSearchResult<Group> result = connector.searchGroups(query, accessToken);
    if(!result.getResources().isEmpty()){
        return result.getResources().get(0);
    }

    return null;
}

@Test
public void filter_groups_where_the_user_is_not_included_in(){
    //check precondition
    Group expectedGroup = getGroupByName(NAME_GROUP_TWO);
    assertNotContainsUser(expectedGroup, testUserId);

    SCIMSearchResult<Group> result = searchGroup("not(members eq \"" + testUserId + "\")");

    assertContainsGroup(NAME_GROUP_TWO, result);
}

private void assertNotContainsUser(Group group, String userId) {
    for(MemberRef ref : group.getMembers()){
        if(userId.equals(ref.getValue())){
            fail("The user is a member of group \"" + group.getDisplayName() + "\"!");
        }
    }
}

private SCIMSearchResult<Group> searchGroup(String filter) {
    QueryBuilder qb = new QueryBuilder();
    qb.filter(filter);

    return connector.searchGroups(qb.build(), accessToken);
}

private void assertContainsGroup(String groupName, SCIMSearchResult<Group> result) {
    for(Group group : result.getResources()){
        if(groupName.equals(group.getDisplayName())){
            return;
        }
    }

    fail("Can not find expected group \"" + groupName + "\"!");
}

@Test
public void filter_users_where_not_a_member_of_group(){
    //check preconditions
    Group expectedGroup = getGroupByName(NAME_GROUP_TWO);
    assertNotContainsUser(expectedGroup, testUserId);

    SCIMSearchResult<User> result = searchUser("not(groups eq \"" + expectedGroup.getId() + "\")");

    assertNotContainsUser(ADMIN_USER_NAME, result);
}


private SCIMSearchResult<User> searchUser(String filter) {
    QueryBuilder qb = new QueryBuilder();
    qb.filter(filter);

    return connector.searchUsers(qb.build(), accessToken);
}

private void assertNotContainsUser(String userName, SCIMSearchResult<User> users) {
    for(User user : users.getResources()){
        if(userName.equals(user.getUserName())){
            fail("The user \"" + userName + "\" is a listed!");
        }
    }
}