testroles.java

找了很久才找到到源代码

/*
 * File   : $Source: /usr/local/cvs/opencms/test/org/opencms/security/TestRoles.java,v $
 * Date   : $Date: 2007-08-13 16:30:12 $
 * Version: $Revision: 1.6 $
 *
 * This library is part of OpenCms -
 * the Open Source Content Management System
 *
 * Copyright (c) 2002 - 2007 Alkacon Software GmbH (http://www.alkacon.com)
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * For further information about Alkacon Software GmbH, please see the
 * company website: http://www.alkacon.com
 *
 * For further information about OpenCms, please see the
 * project website: http://www.opencms.org
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package org.opencms.security;

import org.opencms.file.CmsGroup;
import org.opencms.file.CmsObject;
import org.opencms.file.CmsUser;
import org.opencms.i18n.CmsMessages;
import org.opencms.main.OpenCms;
import org.opencms.test.OpenCmsTestCase;
import org.opencms.test.OpenCmsTestProperties;

import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;

import junit.extensions.TestSetup;
import junit.framework.Test;
import junit.framework.TestSuite;

/**
 * Tests the OpenCms system roles.<p>
 */
public class TestRoles extends OpenCmsTestCase {

    /**
     * Default JUnit constructor.<p>
     * 
     * @param arg0 JUnit parameters
     */
    public TestRoles(String arg0) {

        super(arg0);
    }

    /**
     * Test suite for this test class.<p>
     * Setup is done without importing vfs data.
     * 
     * @return the test suite
     */
    public static Test suite() {

        OpenCmsTestProperties.initialize(org.opencms.test.AllTests.TEST_PROPERTIES_PATH);

        TestSuite suite = new TestSuite();
        suite.setName(TestRoles.class.getName());

        suite.addTest(new TestRoles("testRoleExceptionMessages"));
        suite.addTest(new TestRoles("testRoleAssignments"));
        suite.addTest(new TestRoles("testSubRoles"));
        suite.addTest(new TestRoles("testVirtualRoleGroups"));
        suite.addTest(new TestRoles("testRoleDelegating"));

        TestSetup wrapper = new TestSetup(suite) {

            protected void setUp() {

                setupOpenCms("simpletest", "/sites/default/");
            }

            protected void tearDown() {

                removeOpenCms();
            }
        };

        return wrapper;
    }

    /**
     * Check the given message.<p>
     * 
     * @param message the message to check
     */
    private static void checkMessage(String message) {

        System.out.println(message);
        // check if a key could not be resolved
        assertFalse(message.indexOf(CmsMessages.UNKNOWN_KEY_EXTENSION) >= 0);
        // very simple check if message still containes unresolved '{n}'
        assertFalse(message.indexOf('{') >= 0);
    }

    /**
     * Tests role delegating.<p>
     * 
     * @throws Exception if the test fails
     */
    public void testRoleDelegating() throws Exception {

        echo("Testing role delegating");
        CmsObject cms = getCmsObject();

        CmsRoleManager roleMan = OpenCms.getRoleManager();

        CmsUser user = cms.createUser("testUser", "testUser", "testUser", null);
        roleMan.addUserToRole(cms, CmsRole.ACCOUNT_MANAGER.forOrgUnit(""), user.getName());

        cms.loginUser(user.getName(), "testUser");
        CmsUser u2 = cms.createUser("testUser2", "testUser2", "testUser2", null);

        try {
            roleMan.addUserToRole(cms, CmsRole.DEVELOPER.forOrgUnit(""), u2.getName());
            fail("it should not be possible to delegate a role you do not have");
        } catch (CmsRoleViolationException e) {
            // ok, ignore
        }
        roleMan.addUserToRole(cms, CmsRole.ACCOUNT_MANAGER.forOrgUnit(""), u2.getName());
    }

    /**
     * Tests role assignments.<p>
     * 
     * @throws Exception if the test fails
     */
    public void testRoleAssignments() throws Exception {

        echo("Testing role assignments");
        CmsObject cms = getCmsObject();

        CmsRoleManager roleMan = OpenCms.getRoleManager();
        // check preconditions for admin, with some roles
        roleMan.checkRoleForResource(cms, CmsRole.ROOT_ADMIN, "/");
        roleMan.checkRole(cms, CmsRole.ROOT_ADMIN);
        roleMan.checkRoleForResource(cms, CmsRole.DEVELOPER, "/");
        roleMan.checkRole(cms, CmsRole.DEVELOPER.forOrgUnit(""));
        roleMan.checkRoleForResource(cms, CmsRole.WORKPLACE_MANAGER, "/");
        roleMan.checkRole(cms, CmsRole.WORKPLACE_MANAGER);

        assertFalse(roleMan.getManageableGroups(cms, "", false).isEmpty());
        assertFalse(roleMan.getManageableUsers(cms, "", false).isEmpty());
        assertFalse(roleMan.getOrgUnitsForRole(cms, CmsRole.ADMINISTRATOR.forOrgUnit(""), false).isEmpty());

        assertFalse(roleMan.getRolesOfUser(cms, cms.getRequestContext().currentUser().getName(), "", true, false, false).isEmpty());
        assertTrue(roleMan.getUsersOfRole(cms, CmsRole.ROOT_ADMIN, true, false).contains(
            cms.getRequestContext().currentUser()));
        assertTrue(roleMan.getUsersOfRole(cms, CmsRole.ADMINISTRATOR.forOrgUnit(""), true, true).isEmpty());
        assertEquals(1, roleMan.getUsersOfRole(cms, CmsRole.ADMINISTRATOR.forOrgUnit(""), true, false).size());

        // check preconditions for test user, with some roles
        CmsUser user = cms.readUser("test1");
        assertFalse(roleMan.hasRoleForResource(cms, user.getName(), CmsRole.ROOT_ADMIN, "/"));
        assertFalse(roleMan.hasRole(cms, user.getName(), CmsRole.ROOT_ADMIN));
        assertFalse(roleMan.hasRoleForResource(cms, user.getName(), CmsRole.DEVELOPER, "/"));
        assertFalse(roleMan.hasRole(cms, user.getName(), CmsRole.DEVELOPER.forOrgUnit("")));
        assertFalse(roleMan.hasRoleForResource(cms, user.getName(), CmsRole.WORKPLACE_MANAGER, "/"));
        assertFalse(roleMan.hasRole(cms, user.getName(), CmsRole.WORKPLACE_MANAGER));

        assertEquals(1, roleMan.getRolesOfUser(cms, user.getName(), "", true, false, false).size());
        assertFalse(roleMan.getUsersOfRole(cms, CmsRole.ROOT_ADMIN, true, false).contains(user));
        assertTrue(roleMan.getUsersOfRole(cms, CmsRole.ROOT_ADMIN, true, false).contains(
            cms.getRequestContext().currentUser()));
        assertTrue(roleMan.getUsersOfRole(cms, CmsRole.ADMINISTRATOR.forOrgUnit(""), true, false).contains(
            cms.getRequestContext().currentUser()));

        // login as test user to check if it can create a user
        cms.loginUser(user.getName(), "test1");
        try {
            cms.createUser("mytest", "mytest", "my test", null);
            fail("the user should not have account management permissions");
        } catch (CmsRoleViolationException e) {
            // ok, ignore
        }
        assertTrue(roleMan.getManageableGroups(cms, "", false).isEmpty());
        assertTrue(roleMan.getManageableUsers(cms, "", false).isEmpty());
        assertTrue(roleMan.getOrgUnitsForRole(cms, CmsRole.ADMINISTRATOR.forOrgUnit(""), false).isEmpty());

        // login back as admin
        cms = getCmsObject();