Skip to content
Permalink
master
Go to file
 
 
Cannot retrieve contributors at this time
executable file 2095 lines (1892 sloc) 81.3 KB
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*/
package org.apache.directory.fortress.core.impl;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import org.apache.directory.fortress.core.*;
import org.apache.directory.fortress.core.SecurityException;
import org.apache.directory.fortress.core.model.AdminRole;
import org.apache.directory.fortress.core.model.OrgUnit;
import org.apache.directory.fortress.core.model.PermObj;
import org.apache.directory.fortress.core.model.Permission;
import org.apache.directory.fortress.core.model.Role;
import org.apache.directory.fortress.core.model.Session;
import org.apache.directory.fortress.core.model.User;
import org.apache.directory.fortress.core.model.UserAdminRole;
import org.apache.directory.fortress.core.util.Config;
import org.apache.directory.fortress.core.util.EncryptUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.directory.fortress.core.util.LogUtil;
/**
* DelegatedMgrImpl Tester.
*
* @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
*/
public class DelegatedMgrImplTest extends TestCase
{
private static final String CLS_NM = DelegatedMgrImplTest.class.getName();
private static final Logger LOG = LoggerFactory.getLogger( CLS_NM );
public DelegatedMgrImplTest( String name )
{
super( name );
}
private static Session adminSess = null;
public void setUp() throws Exception
{
super.setUp();
}
public void tearDown() throws Exception
{
super.tearDown();
}
public static Test suitex()
{
TestSuite suite = new TestSuite();
suite.addTest( new DelegatedMgrImplTest( "testRevokePermissionRole" ) );
suite.addTest( new DelegatedMgrImplTest( "testDeassignAdminUser" ) );
suite.addTest( new DelegatedMgrImplTest( "testDeleteUser" ) );
suite.addTest( new DelegatedMgrImplTest( "testDeletePermission" ) );
suite.addTest( new DelegatedMgrImplTest( "testDeleteRole" ) );
suite.addTest( new DelegatedMgrImplTest( "testDeleteOrgInheritance" ) );
suite.addTest( new DelegatedMgrImplTest( "testDeleteOrgUnit" ) );
suite.addTest( new DelegatedMgrImplTest( "testDeleteAdminUser" ) );
suite.addTest( new DelegatedMgrImplTest( "testAddAdminUser" ) );
suite.addTest( new DelegatedMgrImplTest( "testAddOrgUnit" ) );
suite.addTest( new DelegatedMgrImplTest( "testUpdateOrgUnit" ) );
suite.addTest( new DelegatedMgrImplTest( "testAddOrgInheritance" ) );
suite.addTest( new DelegatedMgrImplTest( "testReadOrgUnit" ) );
suite.addTest( new DelegatedMgrImplTest( "testSearchOrgUnits" ) );
suite.addTest( new DelegatedMgrImplTest( "testAddRole" ) );
suite.addTest( new DelegatedMgrImplTest( "testAddUser" ) );
suite.addTest( new DelegatedMgrImplTest( "testAddPermission" ) );
suite.addTest( new DelegatedMgrImplTest( "testAssignAdminUser" ) );
suite.addTest( new DelegatedMgrImplTest( "testGrantPermissionRole" ) );
suite.addTest( new DelegatedMgrImplTest( "testCheckAccess" ) );
suite.addTest( new DelegatedMgrImplTest( "testCanAssignUser" ) );
suite.addTest( new DelegatedMgrImplTest( "testCanDeassignUser" ) );
suite.addTest( new DelegatedMgrImplTest( "testCanGrantPerm" ) );
suite.addTest( new DelegatedMgrImplTest( "testCanRevokePerm" ) );
return suite;
}
public static Test suite()
{
TestSuite suite = new TestSuite();
suite.addTest( new DelegatedMgrImplTest( "testCanAssignUser" ) );
return suite;
}
public void testAddAdminUser()
{
// These fortress delegated admin policies are needed for junit test but may have been created by an ant script so won't need to be created here:
if(loadAdminRequired( "LOAD-ADMIN AROLES_SUPER", AdminRoleTestData.AROLES_SUPER ))
{
addOrgUnit( "ADD ORG_PRM_APP0", OrgUnitTestData.ORGS_PRM_APP0[0] );
addOrgUnit( "ADD ORG_USR_DEV0", OrgUnitTestData.ORGS_USR_DEV0[0] );
addAdminRoles( "ADD-ARLS SUPER", AdminRoleTestData.AROLES_SUPER, false );
AdminMgrImplTest.addPermObjs( "ADD-OBS PSWDMGR_OBJ", PermTestData.PSWDMGR_OBJ, false, false );
AdminMgrImplTest.addPermObjs( "ADD-OBS ADMINMGR_OBJ", PermTestData.ADMINMGR_OBJ, false, false );
AdminMgrImplTest.addPermObjs( "ADD-OBS DELEGATEDMGR_OBJ", PermTestData.DELEGATEDMGR_OBJ, false, false );
AdminMgrImplTest.addPermObjs( "ADD-OBS DELEGATEDREVIEWMGR_OBJ", PermTestData.DELEGATEDREVIEWMGR_OBJ, false,
false );
AdminMgrImplTest.addPermObjs( "ADD-OBS REVIEWMGR_OBJ", PermTestData.REVIEWMGR_OBJ, false, false );
AdminMgrImplTest.addPermObjs( "ADD-OBS GROUPMGR_OBJ", PermTestData.GROUPMGR_OBJ, false, false );
AdminMgrImplTest.addPermOps( "ADD-OPS GROUPMGR_OBJ GROUPMGR_OPS", PermTestData.GROUPMGR_OBJ,
PermTestData.GROUPMGR_OPS, false, false );
AdminMgrImplTest.addPermOps( "ADD-OPS PSWDMGR_OBJ PSWDMGR_OPS", PermTestData.PSWDMGR_OBJ,
PermTestData.PSWDMGR_OPS, false, false );
AdminMgrImplTest.addPermOps( "ADD-OPS ADMINMGR_OBJ ADMINMGR_OPS", PermTestData.ADMINMGR_OBJ,
PermTestData.ADMINMGR_OPS, false, false );
AdminMgrImplTest.addPermOps( "ADD-OPS DELEGATEDMGR_OBJ DELEGATEDMGR_OPS", PermTestData.DELEGATEDMGR_OBJ,
PermTestData.DELEGATEDMGR_OPS, false, false );
AdminMgrImplTest.addPermOps( "ADD-OPS DELEGATEDREVIEWMGR_OBJ DELEGATEDREVIEWMGR_OPS",
PermTestData.DELEGATEDREVIEWMGR_OBJ, PermTestData.DELEGATEDREVIEWMGR_OPS, false, false );
AdminMgrImplTest.addPermOps( "ADD-OPS REVIEWMGR_OBJ REVIEWMGR_OPS", PermTestData.REVIEWMGR_OBJ,
PermTestData.REVIEWMGR_OPS, false, false );
AdminMgrImplTest.addRoleGrants( "GRNT-APRMS SUPER PSWDMGR_OBJ PSWDMGR_OPS", AdminRoleTestData.AROLES_SUPER,
PermTestData.PSWDMGR_OBJ, PermTestData.PSWDMGR_OPS, false, false );
AdminMgrImplTest.addRoleGrants( "GRNT-APRMS SUPER ADMINMGR_OBJ ADMINMGR_OPS", AdminRoleTestData.AROLES_SUPER,
PermTestData.ADMINMGR_OBJ, PermTestData.ADMINMGR_OPS, false, false );
AdminMgrImplTest.addRoleGrants( "GRNT-APRMS SUPER DELEGATEDMGR_OBJ DELEGATEDMGR_OPS",
AdminRoleTestData.AROLES_SUPER, PermTestData.DELEGATEDMGR_OBJ, PermTestData.DELEGATEDMGR_OPS, false, false );
AdminMgrImplTest.addRoleGrants( "GRNT-APRMS SUPER DELEGATEDREVIEWMGR_OBJ DELEGATEDREVIEWMGR_OPS",
AdminRoleTestData.AROLES_SUPER, PermTestData.DELEGATEDREVIEWMGR_OBJ, PermTestData.DELEGATEDREVIEWMGR_OPS,
false, false );
AdminMgrImplTest.addRoleGrants( "GRNT-APRMS SUPER REVIEWMGR_OBJ REVIEWMGR_OPS", AdminRoleTestData.AROLES_SUPER,
PermTestData.REVIEWMGR_OBJ, PermTestData.REVIEWMGR_OPS, false, false );
AdminMgrImplTest.addPermObjs( "ADD-OBS AUDITMGR_OBJ", PermTestData.AUDITMGR_OBJ, false, true );
AdminMgrImplTest.addPermOps( "ADD-OPS AUDITMGR_OBJ AUDITMGR_OPS", PermTestData.AUDITMGR_OBJ,
PermTestData.AUDITMGR_OPS, false, true );
AdminMgrImplTest.addRoleGrants( "GRNT-APRMS SUPER AUDITMGR_OBJ AUDITMGR_OPS", AdminRoleTestData.AROLES_SUPER,
PermTestData.AUDITMGR_OBJ, PermTestData.AUDITMGR_OPS, false, true );
}
PswdPolicyMgrImplTest.add( "ADD " + TestUtils.getDataLabel( PolicyTestData.class, "POLICIES_BASE" ), PolicyTestData.POLICIES_BASE, true );
AdminMgrImplTest.addUsers( "ADD-USRS TU0", UserTestData.USERS_TU0, false );
assignAdminUsers( "ASGN-USRS TU0 SUPER", UserTestData.USERS_TU0, AdminRoleTestData.AROLES_SUPER, false );
}
private static boolean loadAdminRequired( String msg, String[][] rArray )
{
// default return is 'true':
boolean loadAdmin = true;
String methodName = ".loadAdminRequired";
LogUtil.logIt( msg );
try
{
DelReviewMgr dReviewMgr = getDelegatedReviewMgr();
for ( String[] rle : rArray )
{
AdminRole entity = dReviewMgr.readRole( new AdminRole( RoleTestData.getName( rle ) ) );
if(entity == null)
{
break;
}
//AdminRoleTestData.assertEquals( entity, rle );
}
// if we get to here it means that admin role has already been loaded
loadAdmin = false;
}
catch ( SecurityException ex )
{
// This is the expected when teardown is not required:
if ( ex.getErrorId() == GlobalErrIds.ROLE_NOT_FOUND )
{
// did not find so need to load admin roles
}
else
{
// Something unexpected occurred here, Report as warning to the logger:
String warning = methodName + " caught SecurityException=" + ex.getMessage();
LOG.warn( warning );
// TODO: Determine if it would be better to throw a SecurityException here.
}
}
LOG.info( methodName + ":" + loadAdmin );
return loadAdmin;
}
public void testDeleteAdminUser()
{
deassignAdminUsers( "DEASGN-USRS TU0 SUPER", UserTestData.USERS_TU0, AdminRoleTestData.AROLES_SUPER, false );
AdminMgrImplTest.deleteUsers( "DEL-USRS TU0", UserTestData.USERS_TU0, true, false );
AdminMgrImplTest.delRoleGrants( "REVK-APRMS SUPER AUDITMGR_OBJ AUDITMGR_OPS", AdminRoleTestData.AROLES_SUPER,
PermTestData.AUDITMGR_OBJ, PermTestData.AUDITMGR_OPS, false );
AdminMgrImplTest.delRoleGrants( "REVK-APRMS SUPER REVIEWMGR_OBJ REVIEWMGR_OPS", AdminRoleTestData.AROLES_SUPER,
PermTestData.REVIEWMGR_OBJ, PermTestData.REVIEWMGR_OPS, false );
AdminMgrImplTest.delRoleGrants( "REVK-APRMS SUPER PSWDMGR_OBJ PSWDMGR_OPS", AdminRoleTestData.AROLES_SUPER,
PermTestData.PSWDMGR_OBJ, PermTestData.PSWDMGR_OPS, false );
AdminMgrImplTest.delRoleGrants( "REVK-APRMS SUPER ADMINMGR_OBJ ADMINMGR_OPS", AdminRoleTestData.AROLES_SUPER,
PermTestData.ADMINMGR_OBJ, PermTestData.ADMINMGR_OPS, false );
AdminMgrImplTest.delRoleGrants( "REVK-APRMS SUPER DELEGATEDREVIEWMGR_OBJ DELEGATEDREVIEWMGR_OPS",
AdminRoleTestData.AROLES_SUPER, PermTestData.DELEGATEDREVIEWMGR_OBJ, PermTestData.DELEGATEDREVIEWMGR_OPS,
false );
AdminMgrImplTest.delRoleGrants( "REVK-APRMS SUPER DELEGATEDMGR_OBJ DELEGATEDMGR_OPS",
AdminRoleTestData.AROLES_SUPER, PermTestData.DELEGATEDMGR_OBJ, PermTestData.DELEGATEDMGR_OPS, false );
AdminMgrImplTest.delPermOps( "DEL-OPS AUDITMGR_OBJ AUDITMGR_OPS ", PermTestData.AUDITMGR_OBJ,
PermTestData.AUDITMGR_OPS, false, false );
AdminMgrImplTest.delPermOps( "DEL-OPS REVIEWMGR_OBJ REVIEWMGR_OPS ", PermTestData.REVIEWMGR_OBJ,
PermTestData.REVIEWMGR_OPS, false, false );
AdminMgrImplTest.delPermOps( "DEL-OPS PSWDMGR_OBJ PSWDMGR_OPS", PermTestData.PSWDMGR_OBJ,
PermTestData.PSWDMGR_OPS, false, false );
AdminMgrImplTest.delPermOps( "DEL-OPS ADMINMGR_OBJ ADMINMGR_OPS ", PermTestData.ADMINMGR_OBJ,
PermTestData.ADMINMGR_OPS, false, false );
AdminMgrImplTest.delPermOps( "DEL-OPS DELEGATEDREVIEWMGR_OBJ DELEGATEDREVIEWMGR_OPS ",
PermTestData.DELEGATEDREVIEWMGR_OBJ, PermTestData.DELEGATEDREVIEWMGR_OPS, false, false );
AdminMgrImplTest.delPermOps( "DEL-OPS DELEGATEDMGR_OBJ DELEGATEDMGR_OPS ", PermTestData.DELEGATEDMGR_OBJ,
PermTestData.DELEGATEDMGR_OPS, false, false );
AdminMgrImplTest.delPermObjs( "DEL-OBJS AUDITMGR_OBJ", PermTestData.AUDITMGR_OBJ, false );
AdminMgrImplTest.delPermObjs( "DEL-OBJS REVIEWMGR_OBJ", PermTestData.REVIEWMGR_OBJ, false );
AdminMgrImplTest.delPermObjs( "DEL-OBJS PSWDMGR_OBJ", PermTestData.PSWDMGR_OBJ, false );
AdminMgrImplTest.delPermObjs( "DEL-OBJS ADMINMGR_OBJ", PermTestData.ADMINMGR_OBJ, false );
AdminMgrImplTest.delPermObjs( "DEL-OBJS DELEGATEDREVIEWMGR_OBJ", PermTestData.DELEGATEDREVIEWMGR_OBJ, false );
AdminMgrImplTest.delPermObjs( "DEL-OBJS DELEGATEDMGR_OBJ", PermTestData.DELEGATEDMGR_OBJ, false );
deleteAdminRoles( "DEL-ARLS SUPER", AdminRoleTestData.AROLES_SUPER, false );
deleteOrgUnit( "DEL ORG_USR_DEV0", OrgUnitTestData.ORGS_USR_DEV0[0] );
deleteOrgUnit( "DEL ORG_PRM_APP0", OrgUnitTestData.ORGS_PRM_APP0[0] );
}
public void testAssignAdminUser()
{
// public void assignUser(User user, Role role)
assignAdminUsers( "ASGN-USRS TU16 TR1", UserTestData.USERS_TU16_ARBAC, AdminRoleTestData.AROLES_TR1, true );
assignAdminUserRole( "ASGN-USR TU17A TR2", UserTestData.USERS_TU17A_ARBAC, AdminRoleTestData.AROLES_TR2, true );
}
/**
*
* @param msg
* @param uArray
* @param rArray
*/
public static void assignAdminUsers( String msg, String[][] uArray, String[][] rArray, boolean isAdmin )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr;
DelReviewMgr dReviewMgr;
if ( isAdmin )
{
dAdminMgr = getManagedDelegatedMgr();
dReviewMgr = getManagedDelegatedReviewMgr();
}
else
{
dAdminMgr = DelAdminMgrFactory.createInstance( TestUtils.getContext() );
dReviewMgr = DelReviewMgrFactory.createInstance( TestUtils.getContext() );
}
int i = 0;
for ( String[] usr : uArray )
{
i++;
for ( String[] rle : rArray )
{
UserAdminRole uAdminRole = new UserAdminRole( UserTestData.getUserId( usr ), AdminRoleTestData
.getRole( rle ).getName() );
dAdminMgr.assignUser( uAdminRole );
LOG.debug( "assignAdminUsers user [" + uAdminRole.getUserId() + "] role ["
+ uAdminRole.getName() + "] successful" );
// Let's double check the number of users not associated with role:
// This one retrieves the collection of all "roleOccupant" attributes associated with the role node:
List<User> users = dReviewMgr.assignedUsers( AdminRoleTestData.getRole( rle ) );
assertNotNull( users );
assertTrue( CLS_NM + "assignAdminUsers list size check", i == users.size() );
}
}
}
catch ( SecurityException ex )
{
LOG.error(
"assignAdminUsers caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testDeassignAdminUser()
{
// public void deassignUser(User user, Role role)
deassignAdminUsers( "DEASGN-USRS TU16 TR1", UserTestData.USERS_TU16_ARBAC, AdminRoleTestData.AROLES_TR1, true );
deassignAdminUserRole( "DEASGN-USR TU17A TR2", UserTestData.USERS_TU17A_ARBAC, AdminRoleTestData.AROLES_TR2,
true );
}
/**
* @param msg
* @param uArray
* @param rArray
*/
void deassignAdminUsers( String msg, String[][] uArray, String[][] rArray, boolean isAdmin )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr;
DelReviewMgr dReviewMgr;
if ( isAdmin )
{
dAdminMgr = getManagedDelegatedMgr();
dReviewMgr = getManagedDelegatedReviewMgr();
}
else
{
dAdminMgr = DelAdminMgrFactory.createInstance( TestUtils.getContext() );
dReviewMgr = DelReviewMgrFactory.createInstance( TestUtils.getContext() );
}
int i = 0;
for ( String[] usr : uArray )
{
i++;
for ( String[] rle : rArray )
{
UserAdminRole uAdminRole = new UserAdminRole( UserTestData.getUserId( usr ), AdminRoleTestData
.getRole( rle ).getName() );
AdminRoleTestData.getRole( rle );
dAdminMgr.deassignUser( uAdminRole );
LOG.debug( "deassignAdminUsers user [" + uAdminRole.getUserId() + "] role ["
+ uAdminRole.getName() + "] successful" );
// Let's double check the number of users associated with role:
List<User> users = dReviewMgr.assignedUsers( AdminRoleTestData.getRole( rle ) );
assertNotNull( users );
// If this is the last user deassigned from role, both lists will be returned empty:
if ( i == uArray.length )
{
assertTrue( users.size() == 0 );
}
else
{
assertTrue( CLS_NM + "deassignAdminUsers list size check",
( rArray.length - i ) == users.size() );
}
}
}
}
catch ( SecurityException ex )
{
LOG.error(
"deassignAdminUsers caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public static void assignAdminUserRole( String msg, String[][] uArray, String[][] rArray, boolean isAdmin )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr;
if ( isAdmin )
{
dAdminMgr = getManagedDelegatedMgr();
}
else
{
dAdminMgr = DelAdminMgrFactory.createInstance( TestUtils.getContext() );
}
int i = 0;
for ( String[] usr : uArray )
{
UserAdminRole uAdminRole = new UserAdminRole( UserTestData.getUserId( usr ), AdminRoleTestData.getRole(
rArray[i] ).getName() );
dAdminMgr.assignUser( uAdminRole );
i++;
}
}
catch ( SecurityException ex )
{
LOG.error(
"assignAdminUsers caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
void deassignAdminUserRole( String msg, String[][] uArray, String[][] rArray, boolean isAdmin )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr;
if ( isAdmin )
{
dAdminMgr = getManagedDelegatedMgr();
}
else
{
dAdminMgr = DelAdminMgrFactory.createInstance( TestUtils.getContext() );
}
int i = 0;
for ( String[] usr : uArray )
{
UserAdminRole uAdminRole = new UserAdminRole( UserTestData.getUserId( usr ), AdminRoleTestData.getRole(
rArray[i] ).getName() );
dAdminMgr.deassignUser( uAdminRole );
i++;
}
}
catch ( SecurityException ex )
{
LOG.error(
"deassignAdminUserRole caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testAddUser()
{
// public User addUser(User user)
// the admin user must be added before the "addUsers" can be called:
//AdminMgrImplTest.addAdminUser("ADD-USRS TU0", UserTestData.USERS_TU0[0]);
AdminMgrImplTest.addUsers( "ADD-USRS TU16_ARBAC", UserTestData.USERS_TU16_ARBAC, true );
AdminMgrImplTest.addUsers( "ADD-USRS TU16B_ARBAC", UserTestData.USERS_TU16B_ARBAC, true );
AdminMgrImplTest.addUsers( "ADD-USRS TU16A_ARBAC", UserTestData.USERS_TU17A_ARBAC, true );
AdminMgrImplTest.addUsers( "ADD-USRS TU16U_ARBAC", UserTestData.USERS_TU17U_ARBAC, true );
}
public void testDeleteUser()
{
// public void disableUser(User user)
AdminMgrImplTest.deleteUsers( "DEL-USRS TU16B_ARBAC", UserTestData.USERS_TU16B_ARBAC, true, true );
AdminMgrImplTest.deleteUsers( "DEL-USRS TU16_ARBAC", UserTestData.USERS_TU16_ARBAC, true, true );
AdminMgrImplTest.deleteUsers( "DEL-USRS TU16A_ARBAC", UserTestData.USERS_TU17A_ARBAC, true, true );
AdminMgrImplTest.deleteUsers( "DEL-USRS TU16U_ARBAC", UserTestData.USERS_TU17U_ARBAC, true, true );
}
public void testAddPermission()
{
// public Permission addPermObj(Permission pOp)
AdminMgrImplTest.addPermObjs( "ADD-OBS TOB5", PermTestData.OBJS_TOB5, true, false );
AdminMgrImplTest.addPermObjs( "ADD-OBS ARBAC1", PermTestData.ARBAC_OBJS_1, true, false );
AdminMgrImplTest
.addPermOps( "ADD-OPS ARBAC1", PermTestData.ARBAC_OBJS_1, PermTestData.ARBAC_OPS_1, true, false );
AdminMgrImplTest.addPermObjs( "ADD-OBS ARBAC2", PermTestData.ARBAC_OBJ2, true, false );
AdminMgrImplTest.addPermOps( "ADD-OPS ARBAC2", PermTestData.ARBAC_OBJ2, PermTestData.ARBAC_OPS_2, true, false );
}
public void testDeletePermission()
{
// public void deletePermission(Permission pOp)
AdminMgrImplTest.delPermObjs( "DEL-OBJS TOB5", PermTestData.OBJS_TOB5, true );
AdminMgrImplTest
.delPermOps( "DEL-OPS ARBAC1", PermTestData.ARBAC_OBJS_1, PermTestData.ARBAC_OPS_1, true, false );
AdminMgrImplTest.delPermObjs( "DEL-OBJS ARBAC1", PermTestData.ARBAC_OBJS_1, true );
AdminMgrImplTest.delPermOps( "DEL-OPS ARBAC2", PermTestData.ARBAC_OBJ2, PermTestData.ARBAC_OPS_2, true, false );
AdminMgrImplTest.delPermObjs( "DEL-OBS ARBAC2", PermTestData.ARBAC_OBJ2, true );
}
public void testGrantPermissionRole()
{
// public void grantPermission(Permission pOp, Role role)
AdminMgrImplTest.addRoleGrants( "GRNT-APRMS ARTR2 AROBJ1 AROPS1", AdminRoleTestData.AROLES_TR2,
PermTestData.ARBAC_OBJS_1, PermTestData.ARBAC_OPS_1, true, false );
}
public void testRevokePermissionRole()
{
// public void revokePermission(Permission pOp, Role role)
AdminMgrImplTest.delRoleGrants( "REVK-APRMS ARTR2 AROBJ1 AROPS1", AdminRoleTestData.AROLES_TR2,
PermTestData.ARBAC_OBJS_1, PermTestData.ARBAC_OPS_1, true );
}
public void testCheckAccess()
{
// public boolean checkAccess(String object, String operation, Session session)
checkAccess( "CHCK-ACS TU1_UPD TO1 TOP1 ", UserTestData.USERS_TU17A_ARBAC, PermTestData.ARBAC_OBJS_1,
PermTestData.ARBAC_OPS_1, PermTestData.ARBAC_OBJ2, PermTestData.ARBAC_OPS_2 );
}
public static void checkAccess( String msg, String[][] uArray, String[][] oArray, String[][] opArray,
String[][] oArrayBad, String[][] opArrayBad )
{
LogUtil.logIt( msg );
try
{
DelAccessMgr dAccessMgr = DelAccessMgrFactory.createInstance( TestUtils.getContext() );
AccessMgr accessMgr = ( AccessMgr ) dAccessMgr;
for ( String[] usr : uArray )
{
User user = UserTestData.getUser( usr );
Session session = accessMgr.createSession( user, false );
assertNotNull( session );
int i = 0;
for ( String[] obj : oArray )
{
int j = 0;
for ( String[] op : opArray )
{
// Call checkAccess method
assertTrue(
CLS_NM + ".checkAccess failed userId [" + user.getUserId() + "] Perm objName ["
+ PermTestData.getName( obj ) + "] operationName [" + PermTestData.getName( op ) + "]",
dAccessMgr.checkAccess( session,
new Permission( PermTestData.getName( obj ), PermTestData.getName( op ) ) ) );
j++;
}
i++;
}
i = 0;
for ( String[] obj : oArrayBad )
{
int j = 0;
for ( String[] op : opArrayBad )
{
// Call checkAccess method (this should fail):
try
{
boolean result = dAccessMgr.checkAccess( session, new Permission( PermTestData.getName( oArrayBad[i] ),
PermTestData.getName( opArrayBad[j] ) ) );
assertTrue(
CLS_NM + ".checkAccess failed userId [" + user.getUserId() + "] Perm objName ["
+ PermTestData.getName( oArrayBad[i] ) + "] operationName ["
+ PermTestData.getName( opArrayBad[j] ) + "]",
!result );
}
catch (SecurityException se)
{
// The expected condition is security exception perm not exist:
assertTrue( CLS_NM + ".checkAccess failed userId [" + user.getUserId() + "] Perm objName ["
+ PermTestData.getName( oArrayBad[i] ) + "] operationName ["
+ PermTestData.getName( opArrayBad[j] ) + "], negative use case, incorrect exception id=" + se.getErrorId(), se.getErrorId() == GlobalErrIds.PERM_NOT_EXIST );
}
j++;
}
i++;
}
}
LOG.debug( "checkAccess successful" );
}
catch ( SecurityException ex )
{
LOG.error(
"checkAccess: caught SecurityException rc=" + ex.getErrorId() + ", msg: " + ex.getMessage(),
ex );
fail( ex.getMessage() );
}
}
public void testAddRole()
{
// public Role setRole(Role role)
AdminMgrImplTest.addRoles( "ADD-RLS ROLES_TR14_ARBAC", RoleTestData.ROLES_TR14_ARBAC );
AdminMgrImplTest.addInheritedRoles( "ADD-INHERIT-RLS ROLES_TR14_ARBAC", RoleTestData.ROLES_TR14_ARBAC );
AdminMgrImplTest.addRoles( "ADD-RLS ROLES_TR15_ARBAC", RoleTestData.ROLES_TR15_ARBAC );
AdminMgrImplTest.addInheritedRoles( "ADD-INHERIT-RLS ROLES_TR15_ARBAC", RoleTestData.ROLES_TR15_ARBAC );
addAdminRoles( "ADD-ADMRLS TR1", AdminRoleTestData.AROLES_TR1, true );
addAdminRoles( "ADD-ADMRLS TR2", AdminRoleTestData.AROLES_TR2, true );
addAdminRoles( "ADD-ADMRLS TR3", AdminRoleTestData.AROLES_TR3, true );
addAdminRoles( "ADD-ADMRLS TR6", AdminRoleTestData.AROLES_TR6_HIER, true );
}
/**
* @param rArray
*/
public static void addAdminRoles( String msg, String[][] rArray, boolean isAdmin )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr;
if ( isAdmin )
{
dAdminMgr = getManagedDelegatedMgr();
}
else
{
dAdminMgr = DelAdminMgrFactory.createInstance( TestUtils.getContext() );
}
for ( String[] rle : rArray )
{
AdminRole role = AdminRoleTestData.getRole( rle );
AdminRole entity = dAdminMgr.addRole( role );
LOG.debug( "addAdminRoles role [" + entity.getName() + "] successful" );
}
}
catch ( SecurityException ex )
{
LOG.error(
"addAdminRoles caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(),
ex );
fail( ex.getMessage() );
}
}
public void testDeleteRole()
{
// public void deleteRole(Role role)
deleteAdminRoles( "DEL-ADMRLS TR1", AdminRoleTestData.AROLES_TR1, true );
deleteAdminRoles( "DEL-ADMRLS TR2", AdminRoleTestData.AROLES_TR2, true );
deleteAdminRoles( "DEL-ADMRLS TR3", AdminRoleTestData.AROLES_TR3, true );
deleteAdminRoles( "DEL-ADMRLS TR6", AdminRoleTestData.AROLES_TR6_HIER, true );
AdminMgrImplTest.deleteInheritedRoles( "DEL-INHERIT-RLS ROLES_TR14_ARBAC", RoleTestData.ROLES_TR14_ARBAC );
AdminMgrImplTest.deleteRoles( "DEL-RLS ROLES_TR14_ARBAC", RoleTestData.ROLES_TR14_ARBAC );
AdminMgrImplTest.deleteInheritedRoles( "DEL-INHERIT-RLS ROLES_TR15_ARBAC", RoleTestData.ROLES_TR15_ARBAC );
AdminMgrImplTest.deleteRoles( "DEL-RLS ROLES_TR15_ARBAC", RoleTestData.ROLES_TR15_ARBAC );
}
/**
* @param rArray
*/
private void deleteAdminRoles( String msg, String[][] rArray, boolean isAdmin )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr;
if ( isAdmin )
{
dAdminMgr = getManagedDelegatedMgr();
}
else
{
dAdminMgr = DelAdminMgrFactory.createInstance( TestUtils.getContext() );
}
for ( String[] rle : rArray )
{
AdminRole role = new AdminRole();
role.setName( RoleTestData.getName( rle ) );
dAdminMgr.deleteRole( role );
LOG.debug( "deleteAdminRoles role [" + role.getName() + "] successful" );
}
}
catch ( SecurityException ex )
{
LOG.error(
"deleteAdminRoles caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testUpdateAdminRole()
{
// public Role updateRole(Role role)
updateAdminRoles( "UPD-ADMRLS TR3_UPD", AdminRoleTestData.AROLES_TR3_UPD, true );
}
/**
* @param msg
* @param rArray
*/
public static void updateAdminRoles( String msg, String[][] rArray, boolean isAdmin )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr;
if ( isAdmin )
{
dAdminMgr = getManagedDelegatedMgr();
}
else
{
dAdminMgr = DelAdminMgrFactory.createInstance( TestUtils.getContext() );
}
for ( String[] rle : rArray )
{
AdminRole role = AdminRoleTestData.getRole( rle );
AdminRole entity = dAdminMgr.updateRole( role );
LOG.debug( "updateAdminRoles role [" + entity.getName() + "] successful" );
}
}
catch ( SecurityException ex )
{
LOG.error(
"updateAdminRoles caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public enum ASSIGN_OP
{
ASSIGN, DEASSIGN
}
public void testCanAssignUser()
{
//canAssignUsers("CAN-ASGN-USRS TU1 TR1", UserTestData.USERS_TU16_ARBAC, UserTestData.USERS_TU16B_ARBAC, RoleTestData.ROLES_TR14_ARBAC);
canAssignUsers( "CAN-ASGN-USRS URA_T1 TU17A TU17U TR15", ASSIGN_OP.ASSIGN, URATestData.URA_T1,
UserTestData.USERS_TU17A_ARBAC, UserTestData.USERS_TU17U_ARBAC, RoleTestData.ROLES_TR15_ARBAC );
}
public void testCanDeassignUser()
{
canAssignUsers( "CAN-DEASGN-USRS URA_T1 TU17A TU17U TR15", ASSIGN_OP.DEASSIGN, URATestData.URA_T1,
UserTestData.USERS_TU17A_ARBAC, UserTestData.USERS_TU17U_ARBAC, RoleTestData.ROLES_TR15_ARBAC );
}
/**
*
* @param msg
* @param op
* @param uraArray
* @param uaArray
* @param uArray
* @param rArray
*/
public static void canAssignUsers( String msg, ASSIGN_OP op, String[][] uraArray, String[][] uaArray,
String[][] uArray,
String[][] rArray )
{
LogUtil.logIt( msg );
Role role;
Map<URA, URA> uraTestResults = URATestData.getURAs( uraArray );
try
{
DelAccessMgr delAccessMgr = DelAccessMgrFactory.createInstance( TestUtils.getContext() );
AccessMgr accessMgr = ( AccessMgr ) delAccessMgr;
int i = 0;
for ( String[] aUsr : uaArray )
{
User aUser = UserTestData.getUser( aUsr );
Session session = accessMgr.createSession( aUser, false );
assertNotNull( session );
delAccessMgr.setAdmin( session );
for ( String[] usr : uArray )
{
User user = UserTestData.getUser( usr );
i++;
for ( String[] rle : rArray )
{
role = RoleTestData.getRole( rle );
String methodName;
boolean result;
if ( op == ASSIGN_OP.ASSIGN )
{
result = delAccessMgr.canAssign( session, user, role );
methodName = ".canAssignUsers";
}
else
{
result = delAccessMgr.canDeassign( session, user, role );
methodName = ".canDeassignUsers";
}
List<UserAdminRole> aRoles = session.getAdminRoles();
assertNotNull( aRoles );
assertTrue( CLS_NM + methodName + " Admin User invalid number of roles", aRoles.size() == 1 );
// since this user should only have one admin role, get the first one from list:
UserAdminRole aRole = aRoles.get( 0 );
URA sourceUra = new URA( aRole.getName(), user.getOu(), role.getName(), result );
URA targetUra = uraTestResults.get( sourceUra );
assertTrue( CLS_NM + methodName + " cannot find target URA admin role [" + sourceUra.getArole()
+ " uou [" + sourceUra.getUou() + "] role [" + sourceUra.getUrole() + "] Result ["
+ sourceUra.isCanAssign() + "] actual result [" + result + "]", targetUra != null );
LOG.debug( methodName + " User [" + user.getUserId()
+ "] success URA using admin role [" + targetUra.getArole() + " uou [" + targetUra.getUou()
+ "] role [" + targetUra.getUrole() + "] target result [" + targetUra.isCanAssign()
+ "] actual result [" + result + "]" );
}
}
}
}
catch ( SecurityException ex )
{
LOG.error( "canAssignUsers op [" + op + "] caught SecurityException rc=" + ex.getErrorId()
+ ", msg=" + ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testCanGrantPerm()
{
canGrantPerms( "CAN-GRNT-PRMS PRA_T1 TU17A TOB5 TR15", GRANT_OP.GRANT, PRATestData.PRA_T1,
UserTestData.USERS_TU17A_ARBAC, PermTestData.OBJS_TOB5, RoleTestData.ROLES_TR15_ARBAC );
}
public void testCanRevokePerm()
{
canGrantPerms( "CAN-RVKE-PRMS PRA_T1 TU17A TOB5 TR15", GRANT_OP.REVOKE, PRATestData.PRA_T1,
UserTestData.USERS_TU17A_ARBAC, PermTestData.OBJS_TOB5, RoleTestData.ROLES_TR15_ARBAC );
}
public enum GRANT_OP
{
GRANT, REVOKE
}
/**
*
* @param msg
* @param op
* @param uraArray
* @param uaArray
* @param pArray
* @param rArray
*/
public static void canGrantPerms( String msg, GRANT_OP op, String[][] uraArray, String[][] uaArray,
String[][] pArray,
String[][] rArray )
{
LogUtil.logIt( msg );
Role role;
Map<PRA, PRA> praTestResults = PRATestData.getPRAs( uraArray );
try
{
DelAccessMgr delAccessMgr = DelAccessMgrFactory.createInstance( TestUtils.getContext() );
AccessMgr accessMgr = ( AccessMgr ) delAccessMgr;
int i = 0;
for ( String[] aUsr : uaArray )
{
User aUser = UserTestData.getUser( aUsr );
Session session = accessMgr.createSession( aUser, false );
assertNotNull( session );
for ( String[] prm : pArray )
{
PermObj pObj = PermTestData.getObj( prm );
i++;
for ( String[] rle : rArray )
{
role = RoleTestData.getRole( rle );
String methodName;
boolean result;
if ( op == GRANT_OP.GRANT )
{
result = delAccessMgr.canGrant( session, role, new Permission( pObj.getObjName(), "" ) );
methodName = ".canGrantPerms";
}
else
{
result = delAccessMgr.canRevoke( session, role, new Permission( pObj.getObjName(), "" ) );
methodName = ".canRevokePerms";
}
List<UserAdminRole> aRoles = session.getAdminRoles();
assertNotNull( aRoles );
assertTrue( CLS_NM + methodName + " Admin User invalid number of roles", aRoles.size() == 1 );
UserAdminRole aRole = aRoles.get( 0 );
PRA sourceUra = new PRA( aRole.getName(), pObj.getOu(), role.getName(), result );
PRA targetUra = praTestResults.get( sourceUra );
assertTrue( CLS_NM + methodName + " cannot find target PRA admin role [" + sourceUra.getArole()
+ " pou [" + sourceUra.getPou() + "] role [" + sourceUra.getUrole() + "] Result ["
+ sourceUra.isCanAssign() + "] actual result [" + result + "]", targetUra != null );
LOG.debug( methodName + " failed target PRA admin role [" + targetUra.getArole()
+ " pou [" + targetUra.getPou() + "] role [" + targetUra.getUrole() + "] target result ["
+ targetUra.isCanAssign() + "] actual result [" + result + "]" );
}
}
}
}
catch ( SecurityException ex )
{
LOG.error( "canGrantPerms op [" + op + "] caught SecurityException rc=" + ex.getErrorId()
+ ", msg=" + ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testAddOrgUnit()
{
//addOrgUnits("ADD ORGS_USR_DEV0", OrgUnitTestData.ORGS_USR_DEV0);
addOrgUnits( "ADD ORGS_TO1", OrgUnitTestData.ORGS_TO1 );
addOrgUnits( "ADD ORGS_USR_TO2", OrgUnitTestData.ORGS_USR_TO2 );
addOrgUnits( "ADD ORGS_ORGS_PRM_TO3", OrgUnitTestData.ORGS_PRM_TO3 );
addOrgUnits( "ADD ORGS_PRM_TO4", OrgUnitTestData.ORGS_PRM_TO4 );
addOrgUnits( "ADD ORGS_USR_TO5", OrgUnitTestData.ORGS_USR_TO5 );
addOrgUnits( "ADD ORGS_PRM_TO5", OrgUnitTestData.ORGS_PRM_TO5 );
// The DEV1 OU is not removed during cleanup phase because the test system users belong to it:
if ( FortressJUnitTest.isFirstRun() )
{
addOrgUnits( "ADD ORGS_DEV1", OrgUnitTestData.ORGS_DEV1 );
}
addOrgUnits( "ADD ORGS_APP1", OrgUnitTestData.ORGS_APP1 );
}
public static void addOrgUnit( String msg, String[] org )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr = DelAdminMgrFactory.createInstance( TestUtils.getContext() );
OrgUnit ou = OrgUnitTestData.getOrgUnit( org );
OrgUnit entity = dAdminMgr.add( ou );
LOG.debug( "addOrgUnit ou [{}] successful", entity.getName() );
}
catch ( SecurityException ex )
{
LOG.error( "addOrgUnit caught SecurityException rc={}, msg={}", ex.getErrorId(), ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
/**
*
* @param msg
* @param oArray
*/
public static void addOrgUnits( String msg, String[][] oArray )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr = getManagedDelegatedMgr();
for ( String[] ole : oArray )
{
OrgUnit ou = OrgUnitTestData.getOrgUnit( ole );
OrgUnit entity = dAdminMgr.add( ou );
LOG.debug( "addOrgUnits ou [" + entity.getName() + "] successful" );
}
}
catch ( SecurityException ex )
{
LOG.error( "addOrgUnits caught SecurityException=" + ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testDeleteOrgUnit()
{
//deleteOrgUnits("DEL ORGS_USR_DEV0", OrgUnitTestData.ORGS_USR_DEV0);
deleteOrgUnits( "DEL ORGS_TO1", OrgUnitTestData.ORGS_TO1 );
deleteOrgUnits( "DEL ORGS_USR_TO2", OrgUnitTestData.ORGS_USR_TO2 );
deleteOrgUnits( "DEL ORGS_PRM_TO3", OrgUnitTestData.ORGS_PRM_TO3 );
deleteOrgUnits( "DEL ORGS_PRM_TO4", OrgUnitTestData.ORGS_PRM_TO4 );
deleteOrgUnits( "DEL ORGS_USR_TO5", OrgUnitTestData.ORGS_USR_TO5 );
deleteOrgUnits( "DEL ORGS_PRM_TO5", OrgUnitTestData.ORGS_PRM_TO5 );
// Don't delete because the test system users will belong to DEV1 OU and cannot be removed by normal API call:
// deleteOrgUnits("DEL ORGS_DEV1", OrgUnitTestData.ORGS_DEV1);
deleteOrgUnits( "DEL ORGS_APP1", OrgUnitTestData.ORGS_APP1 );
}
/**
*
* @param msg
* @param org
*/
private void deleteOrgUnit( String msg, String[] org )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr = getManagedDelegatedMgr();
OrgUnit ou = OrgUnitTestData.getOrgUnit( org );
dAdminMgr.delete( ou );
LOG.debug( "deleteOrgUnit ou [" + ou.getName() + "] successful" );
}
catch ( SecurityException ex )
{
LOG.error( "deleteOrgUnit caught SecurityException=" + ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
/**
*
* @param msg
* @param oArray
*/
private void deleteOrgUnits( String msg, String[][] oArray )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr = getManagedDelegatedMgr();
for ( String[] ole : oArray )
{
OrgUnit ou = OrgUnitTestData.getOrgUnit( ole );
dAdminMgr.delete( ou );
LOG.debug( "deleteOrgUnits ou [" + ou.getName() + "] successful" );
}
}
catch ( SecurityException ex )
{
LOG.error(
"deleteOrgUnits caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(),
ex );
fail( ex.getMessage() );
}
}
public void testUpdateOrgUnit()
{
updateOrgUnits( "UPD ORGS_TO1", OrgUnitTestData.ORGS_TO1 );
updateOrgUnits( "UPD ORGS_PRM_TO3", OrgUnitTestData.ORGS_PRM_TO3 );
}
/**
*
* @param msg
* @param oArray
*/
public static void updateOrgUnits( String msg, String[][] oArray )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr = getManagedDelegatedMgr();
for ( String[] ole : oArray )
{
OrgUnit ou = OrgUnitTestData.getOrgUnit( ole );
dAdminMgr.update( ou );
LOG.debug( "updateOrgUnits ou [" + ou.getName() + "] successful" );
}
}
catch ( SecurityException ex )
{
LOG.error(
"updateOrgUnits caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(),
ex );
fail( ex.getMessage() );
}
}
public void testReadOrgUnit()
{
// public Role readRole(Role role)
readOrgUnits( "RD ORGS_TO1", OrgUnitTestData.ORGS_TO1 );
readOrgUnits( "RD ORGS_PRM_TO3", OrgUnitTestData.ORGS_PRM_TO3 );
}
/**
*
* @param msg
* @param oArray
*/
public static void readOrgUnits( String msg, String[][] oArray )
{
LogUtil.logIt( msg );
try
{
DelReviewMgr dReviewMgr = getManagedDelegatedReviewMgr();
for ( String[] ole : oArray )
{
OrgUnit ou = OrgUnitTestData.getOrgUnit( ole );
OrgUnit entity = dReviewMgr.read( ou );
OrgUnitTestData.assertEquals( entity, ole );
LOG.debug( "readOrgUnits [" + entity.getName() + "] successful" );
}
}
catch ( SecurityException ex )
{
LOG.error(
"readOrgUnits caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(),
ex );
fail( ex.getMessage() );
}
}
public void testSearchOrgUnits()
{
searchOrgUnits( "SRCH ORGS_TO1",
TestUtils.getSrchValue( OrgUnitTestData.getName( OrgUnitTestData.ORGS_TO1[0] ) ), OrgUnitTestData.ORGS_TO1 );
searchOrgUnits( "SRCH ORGS_PRM_TO3",
TestUtils.getSrchValue( OrgUnitTestData.getName( OrgUnitTestData.ORGS_PRM_TO3[0] ) ),
OrgUnitTestData.ORGS_PRM_TO3 );
}
/**
*
* @param msg
* @param srchValue
* @param oArray
*/
public static void searchOrgUnits( String msg, String srchValue, String[][] oArray )
{
LogUtil.logIt( msg );
try
{
DelReviewMgr dReviewMgr = getManagedDelegatedReviewMgr();
// grab the type from the first entry in the test org list:
OrgUnit.Type type = OrgUnitTestData.getType( oArray[0] );
List<OrgUnit> ous = dReviewMgr.search( type, srchValue );
assertNotNull( ous );
assertTrue( "searchOrgUnits list size check", oArray.length == ous.size() );
for ( String[] ole : oArray )
{
int indx = ous.indexOf( new OrgUnit( OrgUnitTestData.getName( ole ) ) );
if ( indx != -1 )
{
OrgUnit entity = ous.get( indx );
assertNotNull( entity );
OrgUnitTestData.assertEquals( entity, ole );
LOG.debug( "searchOrgUnits [" + entity.getName() + "] successful" );
}
else
{
msg = "searchOrgUnits srchValue [" + srchValue + "] failed list search";
LogUtil.logIt( msg );
fail( msg );
}
}
}
catch ( SecurityException ex )
{
LOG.error(
"searchOrgUnits srchValue [" + srchValue + "] caught SecurityException rc=" + ex.getErrorId()
+ ", msg=" + ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testAddOrgInheritance()
{
addInheritedOrgUnits( "ADD-INHERIT ORGS_USR_TO2", OrgUnitTestData.ORGS_USR_TO2 );
addInheritedOrgUnits( "ADD-INHERIT ORGS_PRM_TO4", OrgUnitTestData.ORGS_PRM_TO4 );
addInheritedOrgUnits( "ADD-INHERIT ORGS_USR_TO5", OrgUnitTestData.ORGS_USR_TO5 );
addInheritedOrgUnits( "ADD-INHERIT ORGS_PRM_TO5", OrgUnitTestData.ORGS_PRM_TO5 );
}
/**
*
* @param msg
* @param oArray
*/
public static void addInheritedOrgUnits( String msg, String[][] oArray )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr = getManagedDelegatedMgr();
for ( String[] ole : oArray )
{
OrgUnit child = OrgUnitTestData.getOrgUnit( ole );
Set<String> parents = new HashSet<String>();
OrgUnitTestData.getRelationship( parents, ole );
for ( String pOrg : parents )
{
OrgUnit parent = new OrgUnit( pOrg );
parent.setType( child.getType() );
dAdminMgr.addInheritance( parent, child );
LOG.debug( "addInheritedOrgUnits child org [" + child.getName() + "] parent org ["
+ pOrg + "] successful" );
}
}
}
catch ( SecurityException ex )
{
LOG.error(
"addInheritedOrgUnits caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testDeleteOrgInheritance()
{
deleteInheritedOrgUnits( "DEL-INHERIT ORGS_USR_TO2", OrgUnitTestData.ORGS_USR_TO2 );
deleteInheritedOrgUnits( "DEL-INHERIT ORGS_PRM_TO4", OrgUnitTestData.ORGS_PRM_TO4 );
deleteInheritedOrgUnits( "DEL-INHERIT ORGS_USR_TO5", OrgUnitTestData.ORGS_USR_TO5 );
deleteInheritedOrgUnits( "DEL-INHERIT ORGS_PRM_TO5", OrgUnitTestData.ORGS_PRM_TO5 );
}
/**
*
* @param msg
* @param oArray
*/
private void deleteInheritedOrgUnits( String msg, String[][] oArray )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr = getManagedDelegatedMgr();
for ( String[] ole : oArray )
{
OrgUnit child = OrgUnitTestData.getOrgUnit( ole );
Set<String> parents = new HashSet<String>();
OrgUnitTestData.getRelationship( parents, ole );
for ( String pOrg : parents )
{
OrgUnit parent = new OrgUnit( pOrg );
parent.setType( child.getType() );
//public void deleteInheritance(OrgUnit parent, OrgUnit child)
dAdminMgr.deleteInheritance( parent, child );
LOG.debug( "deleteInheritedOrgUnits child org [" + child.getName() + "] parent org ["
+ pOrg + "] successful" );
}
}
}
catch ( SecurityException ex )
{
LOG.error( "deleteInheritedOrgUnits caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testReadAdminRole()
{
// public Role readRole(Role role)
readAdminRoles( "RD-ADMRLS TR1", AdminRoleTestData.AROLES_TR1 );
readAdminRoles( "RD-ADMRLS TR2", AdminRoleTestData.AROLES_TR2 );
readAdminRoles( "RD-ADMRLS TR3_UPD", AdminRoleTestData.AROLES_TR3_UPD );
}
/**
*
* @param msg
* @param rArray
*/
public static void readAdminRoles( String msg, String[][] rArray )
{
LogUtil.logIt( msg );
try
{
DelReviewMgr dReviewMgr = getManagedDelegatedReviewMgr();
for ( String[] rle : rArray )
{
AdminRole entity = dReviewMgr.readRole( AdminRoleTestData.getRole( rle ) );
AdminRoleTestData.assertEquals( entity, rle );
LOG.debug( "readAdminRoles [" + entity.getName() + "] successful" );
}
}
catch ( SecurityException ex )
{
LOG.error( "readAdminRoles caught SecurityException=" + ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testSearchAdminRole()
{
searchAdminRoles( "SRCH-ADMRLS TR1",
TestUtils.getSrchValue( RoleTestData.getName( AdminRoleTestData.AROLES_TR1[0] ) ),
AdminRoleTestData.AROLES_TR1 );
searchAdminRoles( "SRCH-ADMRLS TR2",
TestUtils.getSrchValue( RoleTestData.getName( AdminRoleTestData.AROLES_TR2[0] ) ),
AdminRoleTestData.AROLES_TR2 );
searchAdminRoles( "SRCH-ADMRLS TR3",
TestUtils.getSrchValue( RoleTestData.getName( AdminRoleTestData.AROLES_TR3_UPD[0] ) ),
AdminRoleTestData.AROLES_TR3_UPD );
}
/**
*
* @param msg
* @param srchValue
* @param rArray
*/
public static void searchAdminRoles( String msg, String srchValue, String[][] rArray )
{
LogUtil.logIt( msg );
try
{
DelReviewMgr dReviewMgr = getManagedDelegatedReviewMgr();
List<AdminRole> roles = dReviewMgr.findRoles( srchValue );
assertNotNull( roles );
assertTrue( CLS_NM + "searchAdminRoles list size check", rArray.length == roles.size() );
for ( String[] rle : rArray )
{
int indx = roles.indexOf( AdminRoleTestData.getRole( rle ) );
if ( indx != -1 )
{
AdminRole entity = roles.get( indx );
assertNotNull( entity );
AdminRoleTestData.assertEquals( entity, rle );
LOG.debug( "searchAdminRoles [" + entity.getName() + "] successful" );
}
else
{
msg = "searchAdminRoles srchValue [" + srchValue + "] failed list search";
LogUtil.logIt( msg );
fail( msg );
}
}
}
catch ( SecurityException ex )
{
LOG.error(
"searchAdminRoles srchValue [" + srchValue + "] caught SecurityException rc="
+ ex.getErrorId() + ", msg=" + ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testAddOrgUnitDescendant()
{
addOrgUnitDescendant( "ADD ORGS-USR-TO6-DESC", OrgUnitTestData.ORGS_USR_TO6_DSC, OrgUnit.Type.USER );
addOrgUnitDescendant( "ADD ORGS-PRM-TO6-DESC", OrgUnitTestData.ORGS_PRM_TO6_DSC, OrgUnit.Type.PERM );
}
/**
*
* @param msg
* @param oArray
*/
public static void addOrgUnitDescendant( String msg, String[][] oArray, OrgUnit.Type type )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr = getManagedDelegatedMgr();
int ctr = 0;
for ( String[] ole : oArray )
{
OrgUnit orgUnit = OrgUnitTestData.getOrgUnit( ole );
if ( ctr++ == 0 || OrgUnitTestData.isTree( ole ) )
{
dAdminMgr.add( orgUnit );
LOG.debug( "addOrgUnitDescendant add orgUnit [" + orgUnit.getName() + "] successful" );
}
// use list because order is important for test structure:
List<String> descs = new ArrayList<String>();
OrgUnitTestData.getRelationship( descs, ole );
if ( OrgUnitTestData.isTree( ole ) )
{
OrgUnit parent = orgUnit;
for ( String desc : descs )
{
OrgUnit child = new OrgUnit( desc, type );
dAdminMgr.addDescendant( parent, new OrgUnit( desc, type ) );
LOG.debug( "addOrgUnitDescendant asc orgUnit [" + orgUnit.getName()
+ "] desc orgUnit [" + desc + "] successful" );
parent = child;
}
}
else
{
for ( String desc : descs )
{
dAdminMgr.addDescendant( orgUnit, new OrgUnit( desc, type ) );
LOG.debug( "addOrgUnitDescendant asc orgUnit [" + orgUnit.getName()
+ "] desc orgUnit [" + desc + "] successful" );
}
}
Set<String> inheritances = OrgUnitTestData.getInheritances( ole );
if ( inheritances != null )
{
for ( String desc : inheritances )
{
dAdminMgr.addInheritance( orgUnit, new OrgUnit( desc, type ) );
LOG.debug( "addOrgUnitDescendant asc orgUnit [" + orgUnit.getName()
+ "] desc orgUnit [" + desc + "] successful" );
}
}
}
}
catch ( SecurityException ex )
{
LOG.error(
"addOrgUnitDescendant caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testDelOrgUnitDescendant() throws SecurityException
{
delOrgUnitDescendant( "DEL-ORGS-USR-TO6-DESC", OrgUnitTestData.ORGS_USR_TO6_DSC, OrgUnit.Type.USER );
delOrgUnitDescendant( "DEL-ORGS-PRM-TO6-DESC", OrgUnitTestData.ORGS_PRM_TO6_DSC, OrgUnit.Type.PERM );
}
/**
*
* @param msg
*/
private void delOrgUnitDescendant( String msg, String[][] oArray, OrgUnit.Type type )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr = getManagedDelegatedMgr();
for ( String[] ole : oArray )
{
OrgUnit orgUnit = OrgUnitTestData.getOrgUnit( ole );
// use list because order is important for test structure:
List<String> descs = new ArrayList<String>();
OrgUnitTestData.getRelationship( descs, ole );
if ( OrgUnitTestData.isTree( ole ) )
{
OrgUnit parent = orgUnit;
for ( String desc : descs )
{
OrgUnit child = new OrgUnit( desc );
dAdminMgr.deleteInheritance( parent, new OrgUnit( desc, type ) );
LOG.debug( "delOrgUnitDescendant asc orgUnit [" + orgUnit.getName()
+ "] desc orgUnit [" + desc + "] successful" );
parent = child;
}
}
else
{
for ( String desc : descs )
{
dAdminMgr.deleteInheritance( orgUnit, new OrgUnit( desc, type ) );
LOG.debug( "delOrgUnitDescendant asc orgUnit [" + orgUnit.getName()
+ "] desc orgUnit [" + desc + "] successful" );
}
}
Set<String> inheritances = OrgUnitTestData.getInheritances( ole );
if ( inheritances != null )
{
for ( String desc : inheritances )
{
dAdminMgr.deleteInheritance( orgUnit, new OrgUnit( desc, type ) );
LOG.debug( "delOrgUnitDescendant asc orgUnit [" + orgUnit.getName()
+ "] desc orgUnit [" + desc + "] successful" );
}
}
dAdminMgr.delete( orgUnit );
LOG.debug( "delOrgUnitDescendant remove asc orgUnit [" + orgUnit.getName() + "] successful" );
}
// cleanup the last row of descendants from orgUnit data set.
DelReviewMgr dReviewMgr = getManagedDelegatedReviewMgr();
String orgUnitSrchVal = TestUtils.getSrchValue( OrgUnitTestData.getName( oArray[0] ) );
List<OrgUnit> cleanup = dReviewMgr.search( type, orgUnitSrchVal );
for ( OrgUnit oe : cleanup )
{
dAdminMgr.delete( oe );
LOG.debug( "delOrgUnitDescendant cleanup orgUnit [" + oe.getName() + "] successful" );
}
}
catch ( SecurityException ex )
{
LOG.error(
"delOrgUnitDescendant caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testAddOrgUnitAscendants()
{
addOrgUnitAscendant( "ADD-ORGS-USR-TR7-ASC", OrgUnitTestData.ORGS_USR_TO7_ASC, OrgUnit.Type.USER );
addOrgUnitAscendant( "ADD-ORGS-PRM-TR7-ASC", OrgUnitTestData.ORGS_PRM_TO7_ASC, OrgUnit.Type.PERM );
}
/**
*
* @param msg
* @param oArray
* @param type
*/
public static void addOrgUnitAscendant( String msg, String[][] oArray, OrgUnit.Type type )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr = getManagedDelegatedMgr();
for ( String[] ole : oArray )
{
OrgUnit orgUnit = OrgUnitTestData.getOrgUnit( ole );
if ( OrgUnitTestData.isCreate( ole ) )
{
dAdminMgr.add( orgUnit );
LOG.debug( "addOrgUnitAscendant add orgUnit [" + orgUnit.getName() + "] successful" );
}
Set<String> ascs = new HashSet<String>();
OrgUnitTestData.getRelationship( ascs, ole );
for ( String asc : ascs )
{
dAdminMgr.addAscendant( orgUnit, new OrgUnit( asc, type ) );
LOG.debug( "addOrgUnitAscendant desc role [" + orgUnit.getName() + "] asc role ["
+ asc + "] successful" );
}
Set<String> inheritances = OrgUnitTestData.getInheritances( ole );
if ( inheritances != null )
{
for ( String asc : inheritances )
{
dAdminMgr.addInheritance( new OrgUnit( asc, type ), orgUnit );
LOG.debug( "addOrgUnitAscendant desc role [" + orgUnit.getName() + "] asc role ["
+ asc + "] successful" );
}
}
}
}
catch ( SecurityException ex )
{
LOG.error(
"addOrgUnitAscendant caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testDelOrgUnitAscendant()
{
delOrgUnitAscendant( "DEL-ORGS-USR-TR7-ASC", OrgUnitTestData.ORGS_USR_TO7_ASC, OrgUnit.Type.USER );
delOrgUnitAscendant( "DEL-ORGS-PRM-TR7-ASC", OrgUnitTestData.ORGS_PRM_TO7_ASC, OrgUnit.Type.PERM );
}
/**
*
* @param msg
* @param oArray
*/
private void delOrgUnitAscendant( String msg, String[][] oArray, OrgUnit.Type type )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr = getManagedDelegatedMgr();
for ( String[] ole : oArray )
{
OrgUnit orgUnit = OrgUnitTestData.getOrgUnit( ole );
Set<String> ascs = new HashSet<String>();
OrgUnitTestData.getRelationship( ascs, ole );
for ( String asc : ascs )
{
dAdminMgr.deleteInheritance( new OrgUnit( asc, type ), orgUnit );
LOG.debug( "delOrgUnitAscendant desc orgUnit [" + orgUnit.getName()
+ "] asc orgUnit [" + asc + "] successful" );
}
Set<String> inheritances = OrgUnitTestData.getInheritances( ole );
if ( inheritances != null )
{
for ( String asc : inheritances )
{
dAdminMgr.deleteInheritance( new OrgUnit( asc, type ), orgUnit );
LOG.debug( "delOrgUnitAscendant desc orgUnit [" + orgUnit.getName()
+ "] asc orgUnit [" + asc + "] successful" );
}
}
dAdminMgr.delete( orgUnit );
LOG.debug( "delOrgUnitAscendant remove desc orgUnit [" + orgUnit.getName() + "] successful" );
}
// cleanup the top ascendant from orgUnit data set.
DelReviewMgr dReviewMgr = getManagedDelegatedReviewMgr();
String orgUnitSrchVal = OrgUnitTestData.getName( oArray[0] );
// stip off prefix and search:
orgUnitSrchVal = orgUnitSrchVal.substring( 0, 3 );
List<OrgUnit> cleanup = dReviewMgr.search( type, orgUnitSrchVal );
for ( OrgUnit oe : cleanup )
{
dAdminMgr.delete( oe );
LOG.debug( "delOrgUnitAscendant cleanup orgUnit [" + oe.getName() + "] successful" );
}
}
catch ( SecurityException ex )
{
LOG.error(
"delOrgUnitAscendant caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testAddAdminRoleDescendant()
{
addAdminRoleDescendant( "ADD-ARLS-TR5-DESC", AdminRoleTestData.AROLES_TR5_DSC );
}
/**
*
* @param msg
* @param rArray
*/
public static void addAdminRoleDescendant( String msg, String[][] rArray )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr = getManagedDelegatedMgr();
int ctr = 0;
for ( String[] rle : rArray )
{
AdminRole adminRole = AdminRoleTestData.getRole( rle );
if ( ctr++ == 0 || RoleTestData.isTree( rle ) )
{
dAdminMgr.addRole( adminRole );
LOG.debug( "addAdminRoleDescendant add role [" + adminRole.getName() + "] successful" );
}
// use list because order is important for test structure:
List<String> descs = RoleTestData.getRelationshipList( rle );
if ( descs != null )
{
if ( RoleTestData.isTree( rle ) )
{
AdminRole parent = adminRole;
for ( String desc : descs )
{
AdminRole child = new AdminRole( desc );
dAdminMgr.addDescendant( parent, new AdminRole( desc ) );
LOG.debug( "addAdminRoleDescendant asc role [" + adminRole.getName()
+ "] desc role [" + desc + "] successful" );
parent = child;
}
}
else
{
for ( String desc : descs )
{
dAdminMgr.addDescendant( adminRole, new AdminRole( desc ) );
LOG.debug( "addAdminRoleDescendant asc role [" + adminRole.getName()
+ "] desc role [" + desc + "] successful" );
}
}
}
Set<String> inheritances = RoleTestData.getInheritances( rle );
if ( inheritances != null )
{
for ( String desc : inheritances )
{
dAdminMgr.addInheritance( adminRole, new AdminRole( desc ) );
LOG.debug( "addAdminRoleDescendant asc role [" + adminRole.getName()
+ "] desc role [" + desc + "] successful" );
}
}
}
}
catch ( SecurityException ex )
{
LOG.error( "addAdminRoleDescendant caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testDelAdminRoleDescendant() throws SecurityException
{
delAdminRoleDescendant( "DEL-ARLS-TR5-DESC", AdminRoleTestData.AROLES_TR5_DSC );
}
private void delAdminRoleDescendant( String msg, String[][] rArray )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr = getManagedDelegatedMgr();
for ( String[] rle : rArray )
{
AdminRole adminRole = AdminRoleTestData.getRole( rle );
// use list because order is important for test structure:
List<String> descs = RoleTestData.getRelationshipList( rle );
if ( descs != null )
{
if ( RoleTestData.isTree( rle ) )
{
AdminRole parent = adminRole;
for ( String desc : descs )
{
AdminRole child = new AdminRole( desc );
dAdminMgr.deleteInheritance( parent, new AdminRole( desc ) );
LOG.debug( "delAdminRoleDescendant asc adminRole [" + adminRole.getName()
+ "] desc adminRole [" + desc + "] successful" );
parent = child;
}
}
else
{
for ( String desc : descs )
{
dAdminMgr.deleteInheritance( adminRole, new AdminRole( desc ) );
LOG.debug( "delAdminRoleDescendant asc adminRole [" + adminRole.getName()
+ "] desc adminRole [" + desc + "] successful" );
}
}
}
Set<String> inheritances = RoleTestData.getInheritances( rle );
if ( inheritances != null )
{
for ( String desc : inheritances )
{
dAdminMgr.deleteInheritance( adminRole, new AdminRole( desc ) );
LOG.debug( "delAdminRoleDescendant asc adminRole [" + adminRole.getName()
+ "] desc adminRole [" + desc + "] successful" );
}
}
dAdminMgr.deleteRole( adminRole );
LOG.debug( "delAdminRoleDescendant remove asc adminRole [" + adminRole.getName()
+ "] successful" );
}
// cleanup the last row of descendants from orgUnit data set.
DelReviewMgr dReviewMgr = getManagedDelegatedReviewMgr();
String srchVal = TestUtils.getSrchValue( RoleTestData.getName( rArray[0] ) );
List<AdminRole> cleanup = dReviewMgr.findRoles( srchVal );
for ( Role re : cleanup )
{
dAdminMgr.deleteRole( (AdminRole)re );
LOG.debug( "delAdminRoleDescendant cleanup adminRole [" + re.getName() + "] successful" );
}
}
catch ( SecurityException ex )
{
LOG.error(
"delOrgUnitDescendant caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testAddAdminRoleAscendants()
{
addAdminRoleAscendant( "ADD-ARLS-TR4-ASC", AdminRoleTestData.AROLES_TR4_ASC );
}
/**
*
* @param msg
* @param rArray
*/
public static void addAdminRoleAscendant( String msg, String[][] rArray )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr = getManagedDelegatedMgr();
for ( String[] rle : rArray )
{
AdminRole adminRole = AdminRoleTestData.getRole( rle );
if ( RoleTestData.isCreate( rle ) )
{
dAdminMgr.addRole( adminRole );
LOG.debug( "addAdminRoleAscendant add adminRole [" + adminRole.getName() + "] successful" );
}
Set<String> ascs = RoleTestData.getRelationships( rle );
if ( ascs != null )
{
for ( String asc : ascs )
{
dAdminMgr.addAscendant( adminRole, new AdminRole( asc ) );
LOG.debug( "addAdminRoleAscendant desc role [" + adminRole.getName() + "] asc role ["
+ asc + "] successful" );
}
}
Set<String> inheritances = RoleTestData.getInheritances( rle );
if ( inheritances != null )
{
for ( String asc : inheritances )
{
dAdminMgr.addInheritance( new AdminRole( asc ), adminRole );
LOG.debug( "addAdminRoleAscendant desc role [" + adminRole.getName() + "] asc role ["
+ asc + "] successful" );
}
}
}
}
catch ( SecurityException ex )
{
LOG.error(
"addAdminRoleAscendant caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testDelAdminRoleAscendant()
{
delAdminRoleAscendant( "DEL-ARLS-TR4-ASC", AdminRoleTestData.AROLES_TR4_ASC );
}
/**
*
* @param msg
* @param rArray
*/
private void delAdminRoleAscendant( String msg, String[][] rArray )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr = getManagedDelegatedMgr();
for ( String[] rle : rArray )
{
AdminRole adminRole = AdminRoleTestData.getRole( rle );
Set<String> ascs = RoleTestData.getRelationships( rle );
if ( ascs != null )
{
for ( String asc : ascs )
{
dAdminMgr.deleteInheritance( new AdminRole( asc ), adminRole );
LOG.debug( "delAdminRoleAscendant desc adminRole [" + adminRole.getName()
+ "] asc adminRole [" + asc + "] successful" );
}
}
Set<String> inheritances = RoleTestData.getInheritances( rle );
if ( inheritances != null )
{
for ( String asc : inheritances )
{
dAdminMgr.deleteInheritance( new AdminRole( asc ), adminRole );
LOG.debug( "delAdminRoleAscendant desc adminRole [" + adminRole.getName()
+ "] asc orgUnit [" + asc + "] successful" );
}
}
dAdminMgr.deleteRole( adminRole );
LOG.debug( "delAdminRoleAscendant remove desc adminRole [" + adminRole.getName()
+ "] successful" );
}
// cleanup the top ascendant from orgUnit data set.
DelReviewMgr dReviewMgr = getManagedDelegatedReviewMgr();
String adminRoleSrchVal = RoleTestData.getName( rArray[0] );
// stip off prefix and search:
adminRoleSrchVal = adminRoleSrchVal.substring( 0, 3 );
List<AdminRole> cleanup = dReviewMgr.findRoles( adminRoleSrchVal );
for ( AdminRole re : cleanup )
{
dAdminMgr.deleteRole( re );
LOG.debug( "delAdminRoleAscendant cleanup adminRole [" + re.getName() + "] successful" );
}
}
catch ( SecurityException ex )
{
LOG.error(
"delAdminRoleAscendant caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testAddAdminRoleInheritance()
{
addInheritedAdminRoles( "ADD-ARLS-TR6-HIER", AdminRoleTestData.AROLES_TR6_HIER );
}
/**
*
* @param msg
* @param rArray
*/
public static void addInheritedAdminRoles( String msg, String[][] rArray )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr = getManagedDelegatedMgr();
for ( String[] rle : rArray )
{
AdminRole role = AdminRoleTestData.getRole( rle );
Set<String> parents = RoleTestData.getRelationships( rle );
if ( parents != null )
{
for ( String pRole : parents )
{
dAdminMgr.addInheritance( new AdminRole( pRole ), role );
LOG.debug( "addInheritedAdminRoles child role [" + role.getName() + "] parent role ["
+ pRole + "] successful" );
}
}
}
}
catch ( SecurityException ex )
{
LOG.error( "addInheritedAdminRoles caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
public void testDeleteAdminRoleInheritance()
{
deleteInheritedAdminRoles( "DEL-ARLS-TR6-HIER", AdminRoleTestData.AROLES_TR6_HIER );
}
/**
*
* @param msg
* @param rArray
*/
private static void deleteInheritedAdminRoles( String msg, String[][] rArray )
{
LogUtil.logIt( msg );
try
{
DelAdminMgr dAdminMgr = getManagedDelegatedMgr();
for ( String[] rle : rArray )
{
AdminRole role = AdminRoleTestData.getRole( rle );
Set<String> parents = RoleTestData.getRelationships( rle );
if ( parents != null )
{
for ( String pRole : parents )
{
dAdminMgr.deleteInheritance( new AdminRole( pRole ), role );
LOG.debug( "deleteInheritedAdminRoles child role [" + role.getName()
+ "] parent role [" + pRole + "] successful" );
}
}
}
}
catch ( SecurityException ex )
{
LOG.error( "deleteInheritedAdminRoles caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage(), ex );
fail( ex.getMessage() );
}
}
/**
*
* @return
* @throws SecurityException
*/
private static DelReviewMgr getManagedDelegatedReviewMgr() throws SecurityException
{
DelReviewMgr dReviewMgr = DelReviewMgrFactory.createInstance( TestUtils.getContext() );
if ( FortressJUnitTest.isAdminEnabled() && adminSess == null )
{
adminSess = DelegatedMgrImplTest.createAdminSession();
}
dReviewMgr.setAdmin( adminSess );
return dReviewMgr;
}
private static DelReviewMgr getDelegatedReviewMgr() throws SecurityException
{
return DelReviewMgrFactory.createInstance( TestUtils.getContext() );
}
/**
*
* @return
* @throws SecurityException
*/
private static DelAdminMgr getManagedDelegatedMgr() throws SecurityException
{
if ( FortressJUnitTest.isAdminEnabled() && adminSess == null )
{
adminSess = DelegatedMgrImplTest.createAdminSession();
}
return DelAdminMgrFactory.createInstance( TestUtils.getContext(), adminSess );
}
/**
*
* @return
*/
public static boolean loadAdminPolicy()
{
boolean result = true;
try
{
ReviewMgr rMgr = ReviewMgrFactory.createInstance( TestUtils.getContext() );
User admin = UserTestData.getUser( UserTestData.USERS_TU0[0] );
rMgr.readUser( admin );
result = false;
}
catch ( SecurityException se )
{
String info = " loadAdminPolicy detected admin policy not loaded";
LOG.debug( info );
}
return result;
}
/**
*
*/
public static Session createAdminSession()
{
Session adminSess = null;
try
{
AccessMgr accessMgr = AccessMgrFactory.createInstance( TestUtils.getContext() );
User admin;
// If these tests are invoked via REST, the admin creds will configured as fortress.properties, otherwise part of the test data.
if(Config.getInstance().isRestEnabled())
{
admin = new User(Config.getInstance().getProperty( GlobalIds.HTTP_UID_PROP ), Config.getInstance().getProperty( GlobalIds.HTTP_PW_PROP ));
}
else
{
admin = UserTestData.getUser( UserTestData.USERS_TU0[0] );
}
adminSess = accessMgr.createSession( admin, false );
}
catch ( SecurityException ex )
{
String error = " static initializer caught SecurityException rc=" + ex.getErrorId() + ", msg="
+ ex.getMessage();
LOG.error( error );
}
return adminSess;
}
}
You can’t perform that action at this time.