filesystemgroupstester.java

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

    print("Leaving FilesystemGroupsTester.tearDown()");

}
/**
 * Tests IEntityGroupStore.find(), which returns an instance of IEntityGroup
 * given a key.
 */
public void testFind() throws Exception
{
    print("***** ENTERING FilesyStemGroupsTester.testFind() *****" + CR);

    String msg = null;
    Class type = IPERSON_CLASS;
    String existingKey = null, nonExistingKey = null;
    IEntityGroup existingGroup = null;
    File f = null;

    msg = "Finding existing groups by key...";
    print(msg);
    for ( Iterator itr = directoryFiles.iterator(); itr.hasNext(); )
    {
        f = (File) itr.next();
        existingKey = getKeyFromFile(f);
        msg = "Finding group key " + existingKey;
        existingGroup = getGroupStore().find(existingKey);
        assertNotNull(msg, existingGroup);
    }

    nonExistingKey = existingKey + "x";
    msg = "Finding non-existing key: " + nonExistingKey;
    print(msg);
    existingGroup = getGroupStore().find(nonExistingKey);
    assertNull(msg, existingGroup);

    print("Test completed successfully." + CR);

    print("***** LEAVING FileSystemGroupsTester.testFind() *****" + CR);

}
/**
 * Tests IEntityGroupStore.findContainingGroups() for both an IEntity and
 * an IEntityGroup.
 */
public void testFindContainingGroups() throws Exception
{
    print("***** ENTERING FileSystemGroupsTester.testFindContainingGroups() *****" + CR);

    String msg = null;
    Class type = IPERSON_CLASS;
    String ipersonKey = null, groupKey = null;
    IEntityGroup group = null, containingGroup = null;
    IEntity ent = null;
    File f = null;
    Iterator itr = null;
    List containingGroups = new ArrayList();

    msg = "Finding containing groups for entity keys...";
    print(msg);
    for ( int i=0; i<testEntityKeys.length; i++ )
    {
        ent = getNewEntity(testEntityKeys[i]);
        msg = "Finding containing groups for " + ent;
        print(msg);
        containingGroups.clear();
        for (itr = ent.getContainingGroups(); itr.hasNext();)
        {
            group = (IEntityGroup) itr.next();
            containingGroups.add(group);
            assertTrue(msg, group instanceof IEntityGroup);
        }
        assertEquals(msg, keyFiles.size(), containingGroups.size());
    }

    ent = getNewEntity(NON_EXISTENT_ID);
    msg = "Finding containing groups for non-existent key: " + NON_EXISTENT_ID;
    print(msg);
    containingGroups.clear();
    for (itr = ent.getContainingGroups(); itr.hasNext();)
            { containingGroups.add(itr.next()); }
        assertEquals(msg, 0, containingGroups.size());

    msg = "Finding containing groups for groups...";
    print(msg);
    // Each file that contains keys should have 1 and only 1 containing group.
    for ( itr = keyFiles.iterator(); itr.hasNext(); )
    {
        f = (File) itr.next();
        group = findGroup(f);
        assertTrue(msg, group instanceof IEntityGroup);
        containingGroups.clear();

        for (Iterator cg = group.getContainingGroups(); cg.hasNext();)
        {
            containingGroup = (IEntityGroup) cg.next();
            assertTrue(msg, containingGroup instanceof IEntityGroup);
            containingGroups.add(containingGroup);
        }
        assertEquals(msg, 1, containingGroups.size());
    }
    
    msg = "Finding containing groups for a non-existent type...";
    print(msg);

    ent = GroupService.getEntity(testEntityKeys[0], new Object().getClass());
    itr = ent.getContainingGroups();
    boolean hasContainingGroup = itr.hasNext();
    assertTrue(msg, ! hasContainingGroup);
    
    print("Test completed successfully." + CR);

    print("***** LEAVING FileSystemGroupsTester.testFindContainingGroups() *****" + CR);

}
/**
 * Tests IEntityGroupStore.findMemberGroups(), findContainingGroups
 */
public void testFindEmbeddedMemberGroups() throws Exception
{
    print("***** ENTERING FileSystemGroupsTester.testFindEmbeddedMemberGroups() *****" + CR);

    String msg = null;
    IEntityGroup group = null, memberGroup = null;
    File f = null, f2 = null;
    String memberKeys[] = null;

    f = (File)keyFiles.get(keyFiles.size() - 1);  // member
    f2 = (File)keyFiles.get(keyFiles.size() - 2); // group
    String memberKey = getKeyFromFile(f);
    String groupKey = getKeyFromFile(f2);
    
    msg = "Now adding member group key " + memberKey + " to " + groupKey;
    print(msg);
    BufferedWriter bw = new BufferedWriter(new FileWriter(f2.getPath(), true));
    bw.write("group:" + memberKey);
    bw.newLine();
    bw.close();

    msg = "Finding member group keys for key file " + groupKey;
    print(msg);
    group = findGroup(f2);
    assertTrue(msg, group instanceof IEntityGroup);
    memberKeys = getGroupStore().findMemberGroupKeys(group);
    assertEquals(msg, 1, memberKeys.length);
    memberGroup = findGroup(GROUP_SERVICE_NAME + GROUP_SEPARATOR + memberKeys[0]);
    assertNotNull(msg, memberGroup);
    assertTrue(msg, memberGroup.isMemberOf(group));

    print("Test completed successfully." + CR);

    print("***** LEAVING FileSystemGroupsTester.testFindEmbeddedMemberGroups() *****" + CR);

}
/**
 * Tests IEntityGroupStore.findEntitiesForGroup().
 */
public void testFindEntitiesForGroup() throws Exception
{
    print("***** ENTERING FileSystemGroupsTester.testFindEntitiesForGroup() *****" + CR);

    String msg = null;
    IEntityGroup group = null;
    IEntity ent = null;
    File f = null, f2 = null;
    Iterator itr = null;
    List memberEntities = new ArrayList();

    msg = "Finding entities for files...";
    print(msg);

    for ( itr = keyFiles.iterator(); itr.hasNext(); )
    {
        f = (File) itr.next();
        msg = "finding group: " + f;
        group = findGroup(f);
        assertTrue(msg, group instanceof IEntityGroup);
        memberEntities.clear();

        for (Iterator members = group.getEntities(); members.hasNext();)
        {
            ent = (IEntity) members.next();
            assertTrue(msg, ent instanceof IEntity);
            memberEntities.add(ent);
        }
        assertEquals(msg, numTestEntities, memberEntities.size());
    }


    f = (File) keyFiles.get(0);
    f2 = f.getParentFile();
    msg = "Finding entities for " + f2 + " (should have none).";
    group = findGroup(f2);
    assertTrue(msg, group instanceof IEntityGroup);
    boolean hasEntities = group.getEntities().hasNext();
    assertTrue(msg, ! hasEntities);

    msg = "Finding entities for a directory (should be none).";

    print("Test completed successfully." + CR);

    print("***** LEAVING FileSystemGroupsTester.testFindEntitiesForGroup() *****" + CR);

}
/**
 * Tests IEntityGroupStore.findMemberGroupKeys().
 */
public void testFindMemberGroupKeys() throws Exception
{
    print("***** ENTERING FileSystemGroupsTester.testFindMemberGroupKeys() *****" + CR);

    String msg = null;
    IEntityGroup group = null, memberGroup = null;
    File f = null, f2 = null;
    Iterator itr = null;
    String memberKeys[] = null;

    msg = "Finding member group keys for directory files...";
    print(msg);

    for ( itr = directoryFiles.iterator(); itr.hasNext(); )
    {
        f = (File) itr.next();
        msg = "Finding member group keys for group: " + f;
        group = findGroup(f);
        assertTrue(msg, group instanceof IEntityGroup);
        memberKeys = getGroupStore().findMemberGroupKeys(group);
        assertEquals(msg, numTestFiles, memberKeys.length);
        for ( int i=0; i<memberKeys.length; i++ )
        {
            memberGroup = findGroup(GROUP_SERVICE_NAME + GROUP_SEPARATOR + memberKeys[i]);
            assertNotNull(msg, memberGroup);
            assertTrue(msg, memberGroup.isMemberOf(group));
        }
    }

    msg = "Finding member group keys for key files...";
    print(msg);

    for ( itr = keyFiles.iterator(); itr.hasNext(); )
    {
        f = (File) itr.next();
        msg = "Finding member group keys for group: " + f;
        group = findGroup(f);
        assertTrue(msg, group instanceof IEntityGroup);
        memberKeys = getGroupStore().findMemberGroupKeys(group);
        assertEquals(msg, 0, memberKeys.length);
    }


    print("Test completed successfully." + CR);

    print("***** LEAVING FileSystemGroupsTester.testFindMemberGroupKeys() *****" + CR);

}
/**
 * Tests IEntityGroupStore.findMemberGroups().
 */
public void testFindMemberGroups() throws Exception
{
    print("***** ENTERING FileSystemGroupsTester.testFindMemberGroups() *****" + CR);

    String msg = null, groupKey = null;
    IEntityGroup group = null, memberGroup = null;
    File f = null, f2 = null;
    Iterator itr = null;
    Iterator memberGroups = null;

    msg = "Finding member groups for directory files...";
    print(msg);

    for ( itr = directoryFiles.iterator(); itr.hasNext(); )
    {
        f = (File) itr.next();
        msg = "Finding member groups for group: " + f;
        group = findGroup(f);
        assertTrue(msg, group instanceof IEntityGroup);
        memberGroups = getGroupStore().findMemberGroups(group);
        while ( memberGroups.hasNext() )
        {
            memberGroup = (IEntityGroup)memberGroups.next();
            assertNotNull(msg, memberGroup);
            groupKey = GROUP_SERVICE_NAME + GROUP_SEPARATOR + memberGroup.getKey();
            memberGroup = findGroup(groupKey);
            assertTrue(msg, memberGroup.isMemberOf(group));
        }
    }

    msg = "Finding member groups for key files...";
    print(msg);

    for ( itr = keyFiles.iterator(); itr.hasNext(); )
    {
        f = (File) itr.next();
        msg = "Finding member groups for group: " + f;
        group = findGroup(f);
        assertTrue(msg, group instanceof IEntityGroup);
        memberGroups = getGroupStore().findMemberGroups(group);
        assertTrue( msg, ! memberGroups.hasNext() );
    }

    print("Test completed successfully." + CR);

    print("***** LEAVING FileSystemGroupsTester.testFindMemberGroups() *****" + CR);

}
/**
 * Tests IEntityGroupStore.searchForGroups(), which returns EntityIdentifier[] given
 * a search string.
 */
public void testSearchForGroups() throws Exception
{
    print("***** ENTERING FileSystemGroupsTester.testSearchForGroups() *****" + CR);

    String msg = null;
    String is = null, startsWith = null, endsWith = null, contains = null, badQuery = null;
    Class type = IPERSON_CLASS;
    IEntityGroup existingGroup = null;
    IGroupMember member = null;
    EntityIdentifier[] ids = null;

    msg = "Searching for existing groups...";
    print(msg);
    for ( int i=0; i<testFileNames.length; i++ )
    {
        is = testFileNames[i];
        startsWith = is.substring(0, (is.length() - 1) );
        endsWith = is.substring(1);
        contains = is.substring(1, (is.length() - 1));
        badQuery = is + " a b c";

        msg = "Searching for IS " + is;
        ids = getGroupStore().searchForGroups(is, IGroupConstants.IS, type);
        assertEquals(msg, ids.length, 1);
        member = GroupService.findGroup(GROUP_SERVICE_NAME + GROUP_SEPARATOR + ids[0].getKey());
        assertTrue(msg, member.isGroup());

        msg = "Searching for STARTS WITH " + startsWith;
        ids = getGroupStore().searchForGroups(startsWith, IGroupConstants.STARTS_WITH, type);
        assertTrue(msg, ids.length > 0);

        msg = "Searching for ENDS WITH " + endsWith;
        ids = getGroupStore().searchForGroups(endsWith, IGroupConstants.ENDS_WITH, type);
        assertTrue(msg, ids.length > 0);

        msg = "Searching for CONTAINS " + contains;
        ids = getGroupStore().searchForGroups(contains, IGroupConstants.CONTAINS, type);
        assertTrue(msg, ids.length > 0);

        msg = "Searching for IS " + badQuery;
        ids = getGroupStore().searchForGroups(badQuery, IGroupConstants.IS, type);
        assertEquals(msg, ids.length, 0);

    }



    print("Test completed successfully." + CR);

    print("***** LEAVING FileSwystemGroupsTester.testSearchForGroups() *****" + CR);

}
}