groupstester.java

uPortal是开放源码的Portal门户产品

    {
        entityKeys[i] = (getRandomString(random, 3) + i);
        entities[i] = getNewEntity(entityKeys[i]);
    }
    print("Created " + numEntities + " entities.");
    

    print("Creating new group.");
    IEntityGroup bigGroup = getNewGroup();
    bigGroup.setName("Big Group");
    bigGroup.getMembers();
    print("Created" + bigGroup + ".  Will now add members...");    
    
    for (idx=0; idx<numEntities; idx++)
    {
        bigGroup.addMember(entities[idx]);
    }

    msg = "Added " + entities.length + "members.  Will now update.";
    print(msg);
    bigGroup.update();
    print("Finished updating.");
    
    print ("Will un-cache " + bigGroup);
    clearGroupCache();
    
    
    msg = "Finding duplicate group.";
    print(msg);
    String groupKey = bigGroup.getKey();
    IEntityGroup dupBigGroup = GroupService.findGroup(groupKey);
    assertNotNull(msg, dupBigGroup);
    
    int numAdditionalEntities = 10;
    String[] additionalEntityKeys = new String[numAdditionalEntities];
    IEntity[] additionalEntities = new IEntity[numAdditionalEntities];
    
    print("About to create additional entities.");
    for (int i=0; i<numAdditionalEntities; i++)
    {
        additionalEntityKeys[i] = (getRandomString(random, 3) + i);
        additionalEntities[i] = getNewEntity(additionalEntityKeys[i]);
    }
    print("Created " + numAdditionalEntities + " additional entities.");
    
    print("Adding additional entities.");
    for (idx=0; idx<numAdditionalEntities; idx++)
    {
        dupBigGroup.addMember(additionalEntities[idx]);
        print("Added " + additionalEntities[idx]);
        dupBigGroup.update();
    }
    
    print("Done adding additional entities");
    
    print ("Will un-cache " + dupBigGroup);
    clearGroupCache();    
    
    msg = "Retrieving duplicate group a 2nd time.";
    print(msg);
    dupBigGroup = GroupService.findGroup(groupKey);
    assertNotNull(msg, dupBigGroup);
    msg = "Getting members from duplicate group.";
    print(msg);
    Iterator itr = dupBigGroup.getMembers();
    msg = "Done retrieving members.  Will now count members.";
    print(msg);
    int numMembers = 0;
    while ( itr.hasNext() )
    {
        itr.next();
        numMembers++;
    }
    assertEquals(msg, numMembers, (numEntities + numAdditionalEntities));
    


   print(CR + "***** LEAVING GroupsTester.testAddToALargeGroup() *****" + CR);

    }

public void testPagsContains() throws Exception
{
    print(CR + "***** ENTERING GroupsTester.testPagsContains() *****" + CR);
    String message = null;
    boolean result = false;
    
    // We will rely on the groups defined in the sample configuration.
    print("Attempting to retrieve PAGS groups.");
    IEntityGroup pagsRoot = GroupService.findGroup("pags.0");
    IEntityGroup pagsUsers = GroupService.findGroup("pags.1");
    IEntityGroup pagsDs = GroupService.findGroup("pags.3");
    assertNotNull(pagsRoot);
    assertNotNull(pagsUsers);
    assertNotNull(pagsDs);
    print("Found PAGS groups.");
    
    
    message = "PAGS groups should contain no entity members";
    Iterator itr = null;
    Object o = null;
    
    for (itr = pagsRoot.getAllEntities(); itr.hasNext();)
        { o = itr.next(); }
    assertTrue(message, o==null);
    
    for (itr = pagsUsers.getMembers(); itr.hasNext();)
        { o = itr.next(); }
    assertTrue(message, o==null);
    
    for (itr = pagsDs.getMembers(); itr.hasNext();)
        { o = itr.next(); }
    assertTrue(message, o==null);
    
    
    // Entities existing in UP_PERSON_DIR
    IEntity demo = GroupService.getEntity("demo",IPerson.class);
    IEntity admin = GroupService.getEntity("admin",IPerson.class);
    IEntity staff = GroupService.getEntity("staff",IPerson.class);
    
    // Entity not existing in UP_PERSON_DIR
    IEntity testUser = GroupService.getEntity("test",IPerson.class);
        
    message = "pags.1 (users) should contain all entities in UP_PERSON_DIR.";
    result = pagsUsers.contains(demo);
    assertTrue(message,result);
    result = pagsUsers.contains(admin);
    assertTrue(message,result);
    result = pagsUsers.contains(staff);
    assertTrue(message,result);
    
    message = "pags.1 (users) should not contain test entity.";    
    result = pagsUsers.contains(testUser);
    assertTrue(message, ! result);
    
    message = "pags.0 (root) should deepContain all entities in UP_PERSON_DIR.";
    result = pagsRoot.deepContains(demo);
    assertTrue(message,result);
    message = "pags.0 (users) should not deepContain test entity.";    
    result = pagsRoot.deepContains(testUser);
    assertTrue(message, ! result);

   print(CR + "***** LEAVING GroupsTester.testPagsContains() *****" + CR);

    }


/**
 */
public void testAddAndDeleteMembers() throws Exception
{
    print(CR + "***** ENTERING GroupsTester.testAddAndDeleteMembers() *****" + CR);
    String msg = null;
    Class type = TEST_ENTITY_CLASS;
    int totNumGroups = 3;
    int totNumEntities = 5;
    IEntityGroup[] groups = new IEntityGroup[totNumGroups];
    IEntity[] entities = new IEntity[totNumEntities];
    IGroupMember[] groupMembers = null;
    Iterator itr = null;
    ArrayList list = null;
    int idx = 0;

    msg = "Creating " + totNumGroups + " new groups.";
    print(msg);
    for (idx=0; idx<totNumGroups; idx++)
    {
        groups[idx] = getNewGroup();
        assertNotNull(msg, groups[idx]);
    }
    IEntityGroup rootGroup = groups[0];
    IEntityGroup childGroup = groups[1];


    msg = "Adding " + (totNumGroups - 1) + " to root group.";
    print(msg);
    for(idx=1; idx<totNumGroups; idx++)
        { rootGroup.addMember(groups[idx]); }
        
    rootGroup.update();   // in case members not cached.

    msg = "Retrieving members from root group.";
    print(msg);
    list = new ArrayList();
    for( itr=rootGroup.getMembers(); itr.hasNext(); )
        { list.add(itr.next()); }
    assertEquals(msg, (totNumGroups - 1), list.size());

    msg = "Adding " + (totNumEntities - 2) + " to root group.";
    print(msg);
    for(idx=0; idx<(totNumEntities - 2) ; idx++)
        { rootGroup.addMember(testEntities[idx]); }
        
    rootGroup.update();   // in case members not cached.

    msg = "Retrieving members from root group.";
    print(msg);
    list = new ArrayList();
    for( itr=rootGroup.getMembers(); itr.hasNext(); )
        { list.add(itr.next()); }
    assertEquals(msg, (totNumGroups - 1 + totNumEntities - 2), list.size());

    msg = "Adding 2 entities to child group.";
    print(msg);
    childGroup.addMember(testEntities[totNumEntities - 1]);
    childGroup.addMember(testEntities[totNumEntities]);
    
    childGroup.update();   // in case members not cached.

    msg = "Retrieving ALL members from root group.";
    print(msg);
    list = new ArrayList();
    for( itr=rootGroup.getAllMembers(); itr.hasNext(); )
        { list.add(itr.next()); }
    assertEquals(msg, (totNumGroups - 1 + totNumEntities), list.size());

    msg = "Deleting child group from root group.";
    print(msg);
    rootGroup.removeMember(childGroup);
    
    rootGroup.update();   // in case members not cached.

    msg = "Retrieving ALL members from root group.";
    print(msg);
    list = new ArrayList();
    for( itr=rootGroup.getAllMembers(); itr.hasNext(); )
        { list.add(itr.next()); }
    assertEquals(msg, (totNumGroups - 2 + totNumEntities - 2 ), list.size());


    print(CR + "***** LEAVING GroupsTester.testAddAndDeleteMembers() *****" + CR);

}
/**
 */
public void testContains() throws Exception
{
    print(CR + "***** ENTERING GroupsTester.testContains() *****" + CR);
    String msg = null;
    Class type = TEST_ENTITY_CLASS;
    int totNumEntities = 1;
    IEntityGroup containingGroup, childGroup, dupContainingGroup = null;
    IEntity[] entities = new IEntity[totNumEntities];
    IGroupMember[] groupMembers = null;
    Iterator itr = null;
    ArrayList list = null;
    int idx = 0;
    boolean testValue = false;

    msg = "Creating new parent group.";
    print(msg);
    containingGroup = getNewGroup();
    containingGroup.getMembers();   // cache members
    assertNotNull(msg, containingGroup);

    msg = "Creating new child group.";
    print(msg);
    childGroup = getNewGroup();
    childGroup.getMembers();  // cache members
    assertNotNull(msg, childGroup);

    msg = "Creating " + totNumEntities + " new entities.";
    print(msg);
    for(idx=0; idx<totNumEntities; idx++)
        { entities[idx] = getNewEntity("E" + idx); }    


    msg = "Adding " + (totNumEntities) + " to containing group.";
    print(msg);
    for(idx=0; idx<totNumEntities; idx++)
        { containingGroup.addMember(entities[idx]); }

    msg = "Testing if containing group contains entities.";
    print(msg);
    for(idx=0; idx<totNumEntities; idx++)
    { 
        testValue = containingGroup.contains(entities[idx]); 
        assertTrue(msg, testValue);
    }

    msg = "Adding child group to containing group.";
    print(msg);
    containingGroup.addMember(childGroup);

    msg = "Testing if containing group contains child group.";
    print(msg);
    testValue = containingGroup.contains(childGroup); 
    assertTrue(msg, testValue);

    msg = "Updating containing group.";
    print(msg);
    containingGroup.update();

    msg = "Getting duplicate containing group.";
    print(msg);
    dupContainingGroup = findGroup(containingGroup.getKey());
    assertNotNull(msg,dupContainingGroup);

    msg = "Testing if RETRIEVED containing group contains entities.";
    print(msg);
    for(idx=0; idx<totNumEntities; idx++)
    { 
        testValue = dupContainingGroup.contains(entities[idx]); 
        assertTrue(msg, testValue);
    }

    msg = "Testing if RETRIEVED containing group contains child group.";
    print(msg);
    testValue = dupContainingGroup.contains(childGroup);
    assertTrue(msg, testValue);

    msg = "Deleting containing group from db.";
    print(msg);
    containingGroup.delete();



    print(CR + "***** LEAVING GroupsTester.testContains() *****" + CR);

}
/**
 */
public void testDeleteChildGroup() throws Exception
{
    print(CR + "***** ENTERING GroupsTester.testDeleteChildGroup() *****" + CR);
    String msg = null;
    Class type = TEST_ENTITY_CLASS;
    int totNumGroups = 3;
    int totNumEntities = 5;
    IEntityGroup[] groups = new IEntityGroup[totNumGroups];
    IEntity[] entities = new IEntity[totNumEntities];
    IGroupMember[] groupMembers = null;
    Iterator itr = null;
    ArrayList list = null;
    int idx = 0;
    Exception e = null;

    msg = "Creating 3 new groups; 2 parents and 1 child...";
    print(msg);
    
    for (idx=0; idx<totNumGroups; idx++)
    {
        groups[idx] = getNewGroup();
        assertNotNull(msg, groups[idx]);
    }

    IEntityGroup child = groups[0];


    msg = "Adding child to " + (totNumGroups - 1) + " parent groups.";
    print(msg);
    for(idx=1; idx<totNumGroups; idx++)
    { 
        groups[idx].addMember(child);
        groups[idx].update();
	}

    msg = "Retrieving containing groups from child.";
    print(msg);
    list = new ArrayList();
    for( itr=child.getContainingGroups(); itr.hasNext(); )
        { list.add(itr.next()); }
    assertEquals(msg, (totNumGroups - 1), list.size());

    msg = "Adding " + (totNumEntities) + " to child group.";
    print(msg);
    for(idx=0; idx<(totNumEntities) ; idx++)
        { child.addMember(testEntities[idx]); }

    msg = "Retrieving members from child group.";
    print(msg);
    list = new ArrayList();
    for( itr=child.getMembers(); itr.hasNext(); )
        { list.add(itr.next()); }
    assertEquals(msg, (totNumEntities), list.size());

    msg = "Updating child.";
    print(msg);
    child.update();

    msg = "Will now lock one of the parent groups. (Delete of child should fail.)";
    print(msg);
    ILockableEntityGroup lockedParent = findLockableGroup(groups[1].getKey());
    assertNotNull(msg, lockedParent);
    assertTrue(msg, lockedParent.getLock().isValid());
    
    msg = "Deleting child. (Should FAIL).";
    print(msg);
    ILockableEntityGroup legDelete = findLockableGroup(child.getKey());
    try
    {
        legDelete.delete();
    }
    catch (GroupsException ge) { e = ge; }
    assertNotNull(msg, e);
    
    msg = "Will now UN-lock the parent group.";
    print(msg);
    lockedParent.getLock().release();
    assertTrue(msg, ! lockedParent.getLock().isValid());

    msg = "Deleting child.  (Should SUCCEED).";
    print(msg);
    ILockableEntityGroup legDeleteDup = findLockableGroup(child.getKey());
    legDeleteDup.delete();

    msg = "Retrieving members from parent groups (should be EMPTY).";
    print(msg);
    for(idx=1; idx<totNumGroups; idx++)
    { 
        String groupKey = groups[idx].getKey();
        IEntityGroup g = findGroup(groupKey);
        list = new ArrayList();
        for( itr=g.getMembers(); itr.hasNext(); )
            { list.add(itr.next()); }