| package ${package}.services.security; |
| |
| /* |
| * 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. |
| */ |
| import static org.junit.jupiter.api.Assertions.*; |
| |
| import org.apache.fulcrum.security.ModelManager; |
| import org.apache.fulcrum.security.entity.ExtendedUser; |
| import org.apache.fulcrum.security.entity.Group; |
| import org.apache.fulcrum.security.entity.Permission; |
| import org.apache.fulcrum.security.entity.Role; |
| import org.apache.fulcrum.security.model.turbine.TurbineAccessControlList; |
| import org.apache.fulcrum.security.model.turbine.TurbineModelManager; |
| import org.apache.fulcrum.security.model.turbine.entity.TurbineUser; |
| import org.apache.fulcrum.security.model.turbine.entity.TurbineUserGroupRole; |
| import org.apache.fulcrum.security.util.DataBackendException; |
| import org.apache.fulcrum.security.util.EntityExistsException; |
| import org.apache.fulcrum.security.util.UnknownEntityException; |
| import org.apache.fulcrum.testcontainer.BaseUnit5Test; |
| import org.apache.torque.ConstraintViolationException; |
| import org.apache.turbine.annotation.AnnotationProcessor; |
| import org.apache.turbine.annotation.TurbineService; |
| import org.apache.turbine.om.security.DefaultUserImpl; |
| import org.apache.turbine.om.security.User; |
| import org.apache.turbine.services.ServiceManager; |
| import org.apache.turbine.services.TurbineServices; |
| import org.apache.turbine.services.security.SecurityService; |
| import org.apache.turbine.util.TurbineConfig; |
| import org.junit.jupiter.api.BeforeAll; |
| import org.junit.jupiter.api.AfterAll; |
| import org.junit.jupiter.api.BeforeEach; |
| import org.junit.jupiter.api.AfterEach; |
| import org.junit.jupiter.api.Test; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| /** |
| * Test that the SecurityService works properly by comparing behaviour of Turbine and Fulcrum security services using |
| * Torque and Turbine user manager. Requires MySQL |
| * |
| * @author gkallidis |
| * @version $Id$ |
| */ |
| |
| public class TurbineSecurityServiceTest |
| extends BaseUnit5Test |
| { |
| |
| org.apache.fulcrum.security.SecurityService fulcrumSecurityService; |
| |
| @TurbineService |
| SecurityService turbineSecurityService; |
| |
| static TurbineConfig tc; |
| |
| ModelManager modelManager; |
| |
| boolean onDeleteCascade = true; |
| |
| // By default org.slf4j.LoggerFactory is optional in 4.0, but included in webapp |
| Logger log = LoggerFactory.getLogger( getClass().getName() ); |
| |
| @BeforeAll |
| public static void init() |
| throws Exception |
| { |
| tc = new TurbineConfig( ".", "src/test/conf/torque/turbine/CompleteTurbineResources.properties" ); |
| tc.initialize(); |
| } |
| |
| @BeforeEach |
| public void setUpBefore() |
| throws Exception |
| { |
| AnnotationProcessor.process(this); |
| // turbineSecurityService = (SecurityService) TurbineServices.getInstance().getService( SecurityService.SERVICE_NAME ); |
| |
| ServiceManager serviceManager = TurbineServices.getInstance(); |
| fulcrumSecurityService = (org.apache.fulcrum.security.SecurityService) serviceManager.getService( org.apache.fulcrum.security.SecurityService.ROLE ); |
| |
| // setConfigurationFileName("src/test/conf/torque/fulcrumComponentConfiguration.xml"); |
| // setRoleFileName("src/test/conf/torque/fulcrumRoleConfiguration.xml"); |
| // fulcrumSecurityService = (org.apache.fulcrum.security.SecurityService) lookup(org.apache.fulcrum.security.SecurityService.ROLE); |
| // factory = (ACLFactory) lookup(ACLFactory.ROLE); |
| // modelManager = (TurbineModelManager) lookup(TurbineModelManager.ROLE); |
| } |
| |
| @Test |
| public void testAccountExists() |
| throws Exception |
| { |
| // User user = new org.apache.turbine.om.security.DefaultUserImpl(new TurbineUserImpl()); |
| User user = turbineSecurityService.getUserInstance(); |
| user.setAccessCounter( 5 ); |
| assertFalse( turbineSecurityService.accountExists( user ) ); |
| assertFalse( fulcrumSecurityService.getUserManager().checkExists( user ) ); |
| |
| } |
| |
| @Test |
| // @Ignore(value="Turbine security service supported requires Turbine 4.0.1") |
| public void testCreateUser() |
| throws Exception |
| { |
| User user = turbineSecurityService.getUserInstance(); |
| user.setAccessCounter( 5 ); |
| user.setName( "ringo" ); |
| // required not null constraint |
| ( (ExtendedUser) user ).setFirstName( user.getName() ); |
| ( (ExtendedUser) user ).setLastName( user.getName() ); |
| turbineSecurityService.addUser( user, "fakepasswrod" ); |
| assertTrue( turbineSecurityService.accountExists( user ) ); |
| assertTrue( fulcrumSecurityService.getUserManager().checkExists( user ) ); |
| deleteUser( user ); |
| } |
| |
| @Test |
| // @Ignore(value="Turbine security service supported requires Turbine 4.0.1") |
| public void testPermissionRole() |
| { |
| Role role = null; |
| Permission permission = null; |
| Permission permission2 = null; |
| try { |
| role = turbineSecurityService.getRoleInstance( "TEST_SECRETARY" ); |
| role = turbineSecurityService.addRole( role ); |
| permission = turbineSecurityService.getPermissionInstance("TEST_ANSWER_FAX"); |
| permission = turbineSecurityService.addPermission( permission ); |
| |
| permission2 = turbineSecurityService.getPermissionInstance("TEST_ANSWER_PHONE"); |
| turbineSecurityService.addPermission( permission2 ); |
| |
| turbineSecurityService.grant( role, permission ); |
| turbineSecurityService.grant( role, permission2 ); |
| |
| role = turbineSecurityService.getRoleById( (Integer) role.getId()); |
| |
| turbineSecurityService.revokeAll( role ); |
| turbineSecurityService.removeRole( role ); |
| // not necessarily required |
| permission = turbineSecurityService.getPermissionById( (Integer) permission.getId() ); |
| turbineSecurityService.removePermission( permission ); |
| //permission2 = turbineSecurityService.getPermissionByName( permission2.getName() ); |
| //turbineSecurityService.removePermission( permission2 ); |
| } catch (EntityExistsException e) { |
| if (role != null) deleteRole( role ); |
| if (permission != null) deletePermission( permission ); |
| if (permission2 != null) deletePermission( permission2 ); |
| } catch (Exception e) { |
| log.error( "error" , e); |
| fail(); |
| } |
| } |
| |
| /** |
| * Tests Turbine and Fulcrum. |
| * |
| * @throws Exception |
| */ |
| @Test |
| // @Ignore(value="Turbine security service supported requires Turbine 4.0.1") |
| public void testGrantUserGroupRole() |
| throws Exception |
| { |
| Group group = null; |
| Role role = null; |
| User user = null; |
| TurbineUser fulcrumUser = null; |
| try |
| { |
| group = turbineSecurityService.getGroupInstance( "TEST_GROUP" ); |
| group = turbineSecurityService.addGroup( group ); // assign here to delete later as |
| role = turbineSecurityService.getRoleInstance( "TEST_Role" ); |
| role = turbineSecurityService.addRole( role ); |
| // Turbine security service returns a wrapped instance: org.apache.turbine.om.security.DefaultUserImpl |
| // which implements org.apache.turbine.om.security.User |
| user = turbineSecurityService.getUserInstance( "Clint" ); |
| // required not null constraint |
| ( (ExtendedUser) user ).setFirstName( user.getName() ); |
| ( (ExtendedUser) user ).setLastName( user.getName() ); |
| |
| turbineSecurityService.addUser( user, "clint" ); |
| turbineSecurityService.grant( user, group, role ); |
| |
| // existing role |
| Group existingGroup = turbineSecurityService.getGroupByName( "global" ); |
| Role existingRole = turbineSecurityService.getRoleByName( "turbineuser" ); |
| turbineSecurityService.grant( user, existingGroup, existingRole ); |
| assertTrue( user.getUserGroupRoleSet().size() == 2 ); |
| // get fresh db user |
| user = turbineSecurityService.getUser( "Clint" ); |
| existingGroup = turbineSecurityService.getGroupByName( "turbine" ); |
| existingRole = turbineSecurityService.getRoleByName( "turbineadmin" ); |
| turbineSecurityService.grant( user, existingGroup, existingRole ); |
| assertTrue( user.getUserGroupRoleSet().size() == 3 ); |
| |
| TurbineAccessControlList tacl = turbineSecurityService.<TurbineAccessControlList>getACL( user ); |
| |
| assertTrue(tacl.hasRole( existingRole, existingGroup ) ); |
| assertTrue(tacl.hasRole( "turbineuser" )); |
| |
| turbineSecurityService.revoke( user, existingGroup, existingRole ); |
| |
| //user = turbineSecurityService.getUser( "Clint" ); |
| assertTrue( user.getUserGroupRoleSet().size() == 2 ); |
| userGroupRoleCheck( group, role, user.getUserDelegate() ); |
| // compare |
| // Fulcrum security service returns a raw |
| // org.apache.fulcrum.security.model.turbine.entity.impl.TurbineUserImpl, |
| org.apache.fulcrum.security.UserManager userManager = fulcrumSecurityService.getUserManager(); |
| fulcrumUser = userManager.getUserInstance( "Clint2" ); |
| // required not null constraint |
| ( (ExtendedUser) fulcrumUser ).setFirstName( fulcrumUser.getName() ); |
| ( (ExtendedUser) fulcrumUser ).setLastName( fulcrumUser.getName() ); |
| userManager.addUser( fulcrumUser, "clint2" ); |
| ( (TurbineModelManager) fulcrumSecurityService.getModelManager() ).grant( fulcrumUser, group, role ); |
| userGroupRoleCheck( group, role, fulcrumUser ); |
| |
| tacl = turbineSecurityService.getACL( user ); |
| // revoked |
| assertFalse(tacl.hasRole( existingRole, existingGroup ) ); |
| ; |
| |
| |
| } catch (EntityExistsException e) { |
| // cft. finally |
| fail(); |
| } catch (Exception e) { |
| log.error( "error" , e); |
| fail(); |
| } |
| finally |
| { |
| if ( fulcrumUser != null ) |
| deleteUser( new DefaultUserImpl( fulcrumUser ) ); |
| if ( user != null ) |
| deleteUser( user ); |
| // not needed as user remove revokes all : |
| // if (group != null && role != null && user != null) turbineSecurityService.revoke(user, group, role); |
| if ( group != null ) |
| deleteGroup( group ); |
| if ( role != null ) |
| deleteRole( role ); |
| } |
| } |
| |
| public void testCreatingTurbineACLandModel() throws Exception |
| { |
| |
| } |
| |
| |
| /** |
| * Fulcrum contract check |
| * |
| * @param group Fulcrum interface |
| * @param role Fulcrum interface |
| * @param user Fulcrum interface |
| * @throws EntityExistsException |
| * @throws DataBackendException |
| * @throws UnknownEntityException |
| */ |
| private void userGroupRoleCheck( Group group, Role role, TurbineUser user ) throws DataBackendException |
| { |
| |
| boolean ugrFound = false; |
| TurbineUserGroupRole ugrTest = null; |
| for ( TurbineUserGroupRole ugr : ( (TurbineUser) user ).getUserGroupRoleSet() ) |
| { |
| if ( ugr.getUser().equals( user ) && ugr.getGroup().equals( group ) && ugr.getRole().equals( role ) ) |
| { |
| ugrFound = true; |
| ugrTest = ugr; |
| break; |
| } |
| } |
| assertTrue( ugrFound ); |
| assertTrue( ugrTest.getGroup().equals( group ) ); |
| assertTrue( ugrTest.getUser().equals( user ) ); |
| } |
| |
| @AfterAll |
| public static void setupAfter() |
| { |
| ServiceManager serviceManager = TurbineServices.getInstance(); |
| serviceManager.shutdownService( org.apache.turbine.services.security.SecurityService.SERVICE_NAME ); |
| serviceManager.shutdownServices(); |
| // TODO cleanup added users, roles, permissions .. |
| } |
| |
| private void deletePermission( Permission permission ) |
| { |
| try |
| { |
| if (permission.getId() == null) { |
| permission = turbineSecurityService.getPermissionByName(permission.getName() ); |
| } |
| log.info( "deleting permission " + permission.getName() ); |
| turbineSecurityService.removePermission( permission ); |
| permission = null;// not needed |
| } |
| catch ( UnknownEntityException e ) |
| { |
| // not found / existing |
| log.error( e.getMessage(), e ); |
| } |
| catch (Exception e ) { |
| log.error( e.getMessage(), e ); |
| fail(); |
| } |
| } |
| |
| private void deleteRole( Role role ) |
| { |
| try |
| { |
| if (role.getId() == null) { |
| role = turbineSecurityService.getRoleByName(role.getName() ); |
| } |
| log.info( "deleting role " + role.getName() ); |
| turbineSecurityService.removeRole( role ); |
| role = null; |
| } |
| catch ( UnknownEntityException e ) |
| { |
| // not found / existing |
| log.error( e.getMessage(), e ); |
| } |
| catch (Exception e ) { |
| log.error( e.getMessage(), e ); |
| fail(); |
| } |
| } |
| |
| private void deleteGroup( Group group ) |
| { |
| try |
| { |
| if (group.getId() == null) { |
| group = turbineSecurityService.getGroupByName(group.getName() ); |
| } |
| log.info( "deleting group " + group.getName() ); |
| |
| turbineSecurityService.removeGroup( group ); |
| group = null; |
| } |
| catch ( UnknownEntityException e ) |
| { |
| // not found / existing |
| log.error( e.getMessage(), e ); |
| } |
| catch (Exception e ) { |
| log.error( e.getMessage(), e ); |
| fail(); |
| } |
| } |
| |
| private void deleteUser( User user ) |
| { |
| if ( onDeleteCascade ) |
| { |
| try |
| { |
| // revokeAll is called before user delete |
| turbineSecurityService.removeUser( user ); |
| log.info( "try to delete user " + user.getName() ); |
| } |
| catch ( Exception e ) |
| { |
| log.error( "deleting user " + user.getName() + " failed. " + e.getMessage() ); |
| if ( e.getCause() != null && e.getCause() instanceof ConstraintViolationException ) |
| { |
| log.info( "error due to " + e.getCause().getMessage() ); |
| } |
| else |
| { |
| log.info( "error due to " + e.getMessage() ); |
| } |
| } |
| } |
| else |
| { |
| log.info( "onDeleteCascade false, user " + user.getName() + " not deleted!" ); |
| } |
| } |
| |
| } |
