authorizationtester.java

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

package org.jasig.portal.security.provider;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import java.util.Random;

import junit.framework.TestCase;
import junit.framework.TestSuite;

import org.jasig.portal.AuthorizationException;
import org.jasig.portal.concurrency.CachingException;
import org.jasig.portal.concurrency.caching.ReferenceEntityCachingService;
import org.jasig.portal.groups.GroupServiceConfiguration;
import org.jasig.portal.groups.GroupsException;
import org.jasig.portal.groups.IGroupMember;
import org.jasig.portal.properties.PropertiesManager;
import org.jasig.portal.security.IAuthorizationPrincipal;
import org.jasig.portal.security.IAuthorizationService;
import org.jasig.portal.security.IAuthorizationServiceFactory;
import org.jasig.portal.security.IPermission;
import org.jasig.portal.security.IPermissionPolicy;
import org.jasig.portal.security.IPermissionStore;
import org.jasig.portal.security.PortalSecurityException;
import org.jasig.portal.services.AuthorizationService;
import org.jasig.portal.services.GroupService;


/**
 * Tests the authorization framework.
 * @author: Dan Ellentuck
 */
public class AuthorizationTester extends TestCase
{
    private String OWNER = "UP_FRAMEWORK";
    private String TEST_TARGET = "Test_Target.";
    private String TEST_ACTIVITY = "Test_Activity";
    private String EVERYONE_GROUP_KEY;
    private String EVERYONE_GROUP_PRINCIPAL_KEY;
    private String NOONE_GROUP_PRINCIPAL_KEY;
    private String STUDENT_GROUP_PRINCIPAL_KEY;
    private String STUDENT_PRINCIPAL_KEY = "2.student";
    private String GROUP_SEPARATOR;
    private int NUMBER_TEST_PERMISSIONS = 10;

    private IAuthorizationService authorizationService;
    private IPermissionStore permissionStore;
    private IPermissionPolicy defaultPermissionPolicy;
    private IPermissionPolicy negativePermissionPolicy;
    private IPermissionPolicy positivePermissionPolicy;
    private IPermission[] addedPermissions;
    private List testPermissions = new ArrayList();

    private static Class GROUP_CLASS;
    private static Class IPERSON_CLASS;
    private static String CR = "\n";
    
    private Random random = new Random();

    private class NegativePermissionPolicy implements IPermissionPolicy
    {
        private NegativePermissionPolicy() { super(); }
        public boolean doesPrincipalHavePermission(
            IAuthorizationService service,
            IAuthorizationPrincipal principal,
            String owner,
            String activity,
            String target)
        throws AuthorizationException
       {
           return ! (service.equals(service)) &&
                  (principal.equals(principal)) &&
                  (owner.equals(owner)) &&
                  (activity.equals(activity));
       }
        public String toString() { return this.getClass().getName(); }
    }

    private class PositivePermissionPolicy implements IPermissionPolicy
    {
        private PositivePermissionPolicy() { super(); }
        public boolean doesPrincipalHavePermission(
            IAuthorizationService service,
            IAuthorizationPrincipal principal,
            String owner,
            String activity,
            String target)
        throws AuthorizationException
       {
           return (service.equals(service)) &&
                  (principal.equals(principal)) &&
                  (owner.equals(owner)) &&
                  (activity.equals(activity));
       }
        public String toString() { return this.getClass().getName(); }
    }
    
    
    private class PrincipalTester implements Runnable 
    {
        protected Class type;
        protected String key;
        int numTests = 0;
        protected String testerID = null;
        protected String printID = null;
        protected IPermission testPermission;
    
        protected PrincipalTester(String pKey, Class pType, int tests, String id, IPermission permission) 
        {
            super();
            key = pKey;
            type = pType;
            numTests = tests;
            testerID = id;
            testPermission = permission;
        }
        public void run() {
            printID = "Tester " + testerID;
            print(printID + " starting.");

            runAndSleep(numTests, true);
            print(printID + " finished first part of tests.  Will now sleep for 5000 ms to let main thread catch up.");
            try { Thread.sleep(5000); }
                catch (Exception ex) {}
            print(printID + " starting second part of tests.");
            runAndSleep(numTests, false);
            print(printID + " is done.");
        }
 
        private void runAndSleep(int cycles, boolean expectedResult) {
            for (int i=0; i<cycles; i++) 
            {
              //print(printID + " running test # " + (i+1));
                try 
                { 
                    String msg = "Testing  for " + testPermission + " (should be " + expectedResult + ")";
                    boolean testResult = ( runTest() == expectedResult );
                    assertTrue(msg, testResult);
                }
                catch (Exception ex) {} 
                int sleepMillis = random.nextInt(10);
                //print(printID + " will now sleep for " + sleepMillis + " ms.");
                try { Thread.sleep(sleepMillis); }
                catch (Exception ex) {}
            }
        }

        private boolean runTest() throws AuthorizationException {
            IAuthorizationPrincipal principal = getService().newPrincipal(key,type);
            //print("Testing  principal for " + testPermission);
            return principal.hasPermission(OWNER, TEST_ACTIVITY, testPermission.getTarget());
        }
    } 
    
/**
 * AuthorizationTester constructor comment.
 */
public AuthorizationTester(String name) {
    super(name);
}
/**
 *
 */
private void clearGroupCache() throws CachingException
{
    ((ReferenceEntityCachingService) ReferenceEntityCachingService.singleton())
        .getCache(GROUP_CLASS).clearCache();
}
/**
 * @return org.jasig.portal.security.IPermissionPolicy
 */
private IPermissionPolicy getDefaultPermissionPolicy() throws AuthorizationException
{
    if ( defaultPermissionPolicy == null )
        { initializeDefaultPermissionPolicy(); }
    return defaultPermissionPolicy;
}
/**
 * @return org.jasig.portal.services.GroupService
 */
private Collection getGroupMembers(IGroupMember gm) throws GroupsException
{
    Collection list = new ArrayList();
    for( Iterator itr=gm.getMembers(); itr.hasNext(); )
        { list.add(itr.next()); }
    return list;
}
/**
 * @return org.jasig.portal.security.IPermissionPolicy
 */
private IPermissionPolicy getNegativePermissionPolicy() throws AuthorizationException
{
    if ( negativePermissionPolicy == null )
        { negativePermissionPolicy = new AuthorizationTester.NegativePermissionPolicy(); }
    return negativePermissionPolicy;
}
/**
 * @return org.jasig.portal.security.IPermissionStore
 */
private IPermissionStore getPermissionStore() throws AuthorizationException
{
    if ( permissionStore == null )
        { initializePermissionStore(); }
    return permissionStore;
}
/**
 * @return org.jasig.portal.security.IPermissionPolicy
 */
private IPermissionPolicy getPositivePermissionPolicy() throws AuthorizationException
{
    if ( positivePermissionPolicy == null )
        { positivePermissionPolicy = new AuthorizationTester.PositivePermissionPolicy(); }
    return positivePermissionPolicy;
}
/**
 * @return org.jasig.portal.security.AuthorizationService
 */
private IAuthorizationService getService() throws AuthorizationException
{
    if ( authorizationService == null )
        { initializeAuthorizationService(); }
    return authorizationService;
}
/**
 * Create an implementation of IAuthorizationService.
 */
private void initializeAuthorizationService() throws AuthorizationException
{
    // Get the security properties file
    java.io.InputStream secprops = AuthorizationService.class.getResourceAsStream("/properties/security.properties");

    // Get the properties from the security properties file
    Properties pr = new Properties();
    String s_factoryName = null;

    try
    {
        pr.load(secprops);
        // Look for our authorization factory and instantiate an instance of it or die trying.
        if ((s_factoryName = pr.getProperty("authorizationProvider")) == null)
        {
            print ("ERROR: AuthorizationProvider not specified or incorrect in security.properties");
        }
        else
        {
            try
            {
                IAuthorizationServiceFactory factory = (IAuthorizationServiceFactory)Class.forName(s_factoryName).newInstance();
                authorizationService = factory.getAuthorization();
            }
            catch (Exception e)
            {
                print ("ERROR: Failed to instantiate " + s_factoryName);
            }
        }

    }
    catch (IOException e)
    {
        print ("ERROR: " + e.getMessage());
    } finally {
			try {
				if (secprops != null)
					secprops.close();
			} catch (IOException ioe) {
				print(new PortalSecurityException(ioe.getMessage()).toString());
			}
	}
}
/**
 * Create the default implementation of IPermissionPolicy.
 */
private void initializeDefaultPermissionPolicy() throws AuthorizationException
{
    String eMsg = null;
    String policyName =
      PropertiesManager.getProperty("org.jasig.portal.security.IPermissionPolicy.defaultImplementation");
    if ( policyName == null )
    {
        eMsg = "AuthorizationTester.initializeDefaultPermissionPolicy(): No entry for org.jasig.portal.security.IPermissionPolicy.defaultImplementation in portal.properties.";
        print (eMsg);
        throw new AuthorizationException(eMsg);
    }

    try
    {
        defaultPermissionPolicy = (IPermissionPolicy)Class.forName(policyName).newInstance();
    }
    catch (Exception e)
    {
        eMsg = "AuthorizationTester.initializeDefaultPermissionPolicy(): Problem creating default permission policy... " + e.getMessage();
        print(eMsg);
        throw new AuthorizationException(eMsg);
    }
}
/**
 * Create an implementation of IPermissionStore.
 */
private void initializePermissionStore() throws AuthorizationException
{
    String eMsg = null;
    String factoryName =
      PropertiesManager.getProperty("org.jasig.portal.security.IPermissionStore.implementation");
    if ( factoryName == null )
    {
        eMsg = "AuthorizationTester.initializePermissionStore(): No entry for org.jasig.portal.security.IPermissionStore.implementation portal.properties.";
        print(eMsg);
        throw new AuthorizationException(eMsg);
    }

    try
    {
        permissionStore = (IPermissionStore)Class.forName(factoryName).newInstance();
    }
    catch (Exception e)
    {
        eMsg = "AuthorizationTester.initializePermissionStore(): Problem creating permission store... " + e.getMessage();
        print(eMsg);
        throw new AuthorizationException(eMsg);
    }
}
/**
 * Starts the application.
 * @param args an array of command-line arguments
 */
public static void main(java.lang.String[] args) throws Exception
{
    String[] mainArgs = {"org.jasig.portal.security.provider.AuthorizationTester"};
    print("START TESTING AUTHORIZATION SERVICE");
    printBlankLine();
    junit.swingui.TestRunner.main(mainArgs);
    printBlankLine();
    print("END TESTING AUTHORIZATION SERVICE");

}
/**
 * @param msg java.lang.String
 */
private static void print(String msg)
{
    java.sql.Timestamp ts = new java.sql.Timestamp(System.currentTimeMillis());
    System.out.println(ts + " : " + msg);
}
private static void printBlankLine()
{
    System.out.println("");
}
/**
 */
protected void setUp()
{
    String msg = null;
    IPermission[] retrievedPermissions = null;
    IPermission newPermission, retrievedPermission = null;
    java.util.Date effectiveDate = new java.util.Date();
    java.util.Date expirationDate = new java.util.Date(System.currentTimeMillis() + (60 * 60 * 24 * 1000));
    int idx = 0;

    try
    {
        if ( GROUP_CLASS == null )
            { GROUP_CLASS = Class.forName("org.jasig.portal.groups.IEntityGroup"); }
        if ( IPERSON_CLASS == null )
            { IPERSON_CLASS = Class.forName("org.jasig.portal.security.IPerson"); }
            
        GROUP_SEPARATOR = GroupServiceConfiguration.getConfiguration().getNodeSeparator();
        EVERYONE_GROUP_KEY = "local" + GROUP_SEPARATOR + "0";