Added: turbine/fulcrum/trunk/security/torque/src/test/org/apache/fulcrum/security/torque/turbine/TurbineUserManagerWithDefaultPeerLazyTest.java URL: http://svn.apache.org/viewvc/turbine/fulcrum/trunk/security/torque/src/test/org/apache/fulcrum/security/torque/turbine/TurbineUserManagerWithDefaultPeerLazyTest.java?rev=1884679&view=auto ============================================================================== --- turbine/fulcrum/trunk/security/torque/src/test/org/apache/fulcrum/security/torque/turbine/TurbineUserManagerWithDefaultPeerLazyTest.java (added) +++ turbine/fulcrum/trunk/security/torque/src/test/org/apache/fulcrum/security/torque/turbine/TurbineUserManagerWithDefaultPeerLazyTest.java Mon Dec 21 12:56:47 2020 @@ -0,0 +1,521 @@ +package org.apache.fulcrum.security.torque.turbine; + +/* + * 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.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; + +import java.sql.Connection; +import java.sql.SQLException; + +import org.apache.fulcrum.security.SecurityService; +import org.apache.fulcrum.security.UserManager; +import org.apache.fulcrum.security.acl.AccessControlList; +import org.apache.fulcrum.security.entity.Group; +import org.apache.fulcrum.security.entity.Role; +import org.apache.fulcrum.security.entity.User; +import org.apache.fulcrum.security.model.test.AbstractUserManagerTest; +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.torque.HsqlDB; +import org.apache.fulcrum.security.torque.om.TurbineGroupPeer; +import org.apache.fulcrum.security.torque.om.TurbinePermissionPeer; +import org.apache.fulcrum.security.torque.om.TurbineRolePeer; +import org.apache.fulcrum.security.torque.om.TurbineRolePermissionPeer; +import org.apache.fulcrum.security.torque.om.TurbineUserPeer; +import org.apache.fulcrum.security.util.DataBackendException; +import org.apache.fulcrum.security.util.EntityExistsException; +import org.apache.fulcrum.security.util.PasswordMismatchException; +import org.apache.fulcrum.security.util.UnknownEntityException; +import org.apache.fulcrum.security.util.UserSet; +import org.apache.fulcrum.testcontainer.BaseUnit5Test; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.apache.torque.TorqueException; +import org.apache.torque.criteria.Criteria; +import org.apache.torque.util.Transaction; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +/** + * @author Eric Pugh + * @author Georg Kallidis Same as {@link AbstractUserManagerTest} in Fulcrum API module, but with user-group-role-sets + * added and checked + */ +public class TurbineUserManagerWithDefaultPeerLazyTest + extends BaseUnit5Test +{ + protected User user; + + protected UserManager userManager; + + protected SecurityService securityService; + + protected static final String TEST_GROUP = "TEST_GROUP"; + + private static final String TEST_ROLE = "TEST_Role"; + + private Group group; + + private Role role; + + private Logger logger = LogManager.getLogger(); + + private static HsqlDB hsqlDB = null; + + @BeforeEach + public void setUp() + { + try + { + hsqlDB = new HsqlDB( "src/test/fulcrum-turbine-default-schema.sql" ); + + this.setRoleFileName( "src/test/TurbineTorqueRoleConfig.xml" ); + // we have to use declared peers + this.setConfigurationFileName( "src/test/TurbineDefaultLazyWithPeersComponentConfig.xml" ); + securityService = (SecurityService) lookup( SecurityService.ROLE ); + userManager = securityService.getUserManager(); + + group = securityService.getGroupManager().getGroupInstance(); + group.setName( "TEST_GROUP" ); + securityService.getGroupManager().addGroup( group ); + role = securityService.getRoleManager().getRoleInstance(); + role.setName( "TEST_Role" ); + securityService.getRoleManager().addRole( role ); + + } + catch ( Exception e ) + { + fail( e.toString() ); + } + } + + @Override + @AfterEach + public void tearDown() + { + + // cleanup tables + Connection con = null; + try + { + con = Transaction.begin();// "default" + + Criteria criteria = new Criteria(); + // criteria.where(TurbineUserGroupRolePeer.USER_ID, -1, Criteria.GREATER_THAN); + // int deletedRows = TurbineUserGroupRolePeer.doDelete(criteria,con); + + if ( user != null ) + { + try + { + securityService.<TurbineModelManager> getModelManager().revokeAll( user ); + } + catch ( DataBackendException e ) + { + e.printStackTrace(); + fail(); + } + catch ( UnknownEntityException e ) + { + // may be thrown, if user not exists if instance was not added to manager + } + } + + criteria = new Criteria(); + criteria.where( TurbineRolePermissionPeer.ROLE_ID, 0, Criteria.GREATER_THAN ); + TurbineRolePermissionPeer.doDelete( criteria, con ); + + criteria = new Criteria(); + criteria.where( TurbineUserPeer.USER_ID, 0, Criteria.GREATER_THAN ); + TurbineUserPeer.doDelete( criteria, con ); + + criteria = new Criteria(); + criteria.where( TurbineGroupPeer.GROUP_ID, 0, Criteria.GREATER_THAN ); + TurbineGroupPeer.doDelete( criteria, con ); + + criteria = new Criteria(); + criteria.where( TurbineRolePeer.ROLE_ID, 0, Criteria.GREATER_THAN ); + TurbineRolePeer.doDelete( criteria, con ); + + criteria = new Criteria(); + criteria.where( TurbinePermissionPeer.PERMISSION_ID, 0, Criteria.GREATER_THAN ); + TurbinePermissionPeer.doDelete( criteria, con ); + + con.commit(); + con = null; + } + catch ( TorqueException e ) + { + fail( e.toString() ); + } + catch ( SQLException e ) + { + if ( con != null ) + { + Transaction.safeRollback( con ); + } + fail( e.toString() ); + } + + user = null; + userManager = null; + securityService = null; + } + + + + // requires default user in setup + @Test + public void testCheckExists() + throws Exception + { + user = userManager.getUserInstance( "Philip" ); + userManager.addUser( user, "bobo" ); + addDefaultGrantUserGroupRole( user ); + + assertTrue( userManager.checkExists( "philip" ) ); + assertTrue( userManager.checkExists( user ) ); + assertFalse( userManager.checkExists( "ImaginaryFriend" ) ); + user = userManager.getUserInstance( "ImaginaryFriend" ); + assertFalse( userManager.checkExists( user ) ); + } + + @Test + public void testCheckExistsWithString() + throws Exception + { + user = userManager.getUserInstance( "Philip2" ); + userManager.addUser( user, "bobo" ); + addDefaultGrantUserGroupRole( user ); + + assertTrue( userManager.checkExists( "philip2" ) ); + assertTrue( userManager.checkExists( user.getName() ) ); + assertFalse( userManager.checkExists( "ImaginaryFriend2" ) ); + user = userManager.getUserInstance( "ImaginaryFriend2" ); + assertFalse( userManager.checkExists( user.getName() ) ); + } + + /* + * Class to test for User retrieve(String) + */ + @Test + public void testGetUserString() + throws Exception + { + user = userManager.getUserInstance( "QuietMike" ); + userManager.addUser( user, "bobo" ); + addDefaultGrantUserGroupRole( user ); + + user = userManager.getUser( "QuietMike" ); + Assertions.assertNotNull( user ); + } + + @Test + public void testGetUserById() + throws Exception + { + user = userManager.getUserInstance( "QuietMike2" ); + userManager.addUser( user, "bobo" ); + User user2 = userManager.getUserById( user.getId() ); + assertEquals( user.getName(), user2.getName() ); + assertEquals( user.getId(), user2.getId() ); + } + + /* + * Class to test for User retrieve(String, String) + */ + @Test + public void testGetUserStringString() + throws Exception + { + user = userManager.getUserInstance( "Richard" ); + userManager.addUser( user, "va" ); + + addDefaultGrantUserGroupRole( user ); + + user = userManager.getUser( "Richard", "va" ); + Assertions.assertNotNull( user ); + user = userManager.getUser( "richard", "va" ); + assertNotNull( user ); + try + { + user = userManager.getUser( "richard", "VA" ); + fail( "should have thrown PasswordMismatchException" ); + } + catch ( PasswordMismatchException pme ) + { + // good + } + } + + @Test + public void testGetAllUsers() + throws Exception + { + int size = userManager.getAllUsers().size(); + user = userManager.getUserInstance( "Bob" ); + userManager.addUser( user, "" ); + addDefaultGrantUserGroupRole( user ); + + UserSet<User> userSet = userManager.getAllUsers(); + assertEquals( size + 1, userSet.size() ); + } + + @Test + public void testAuthenticate() + throws Exception + { + user = userManager.getUserInstance( "Kay" ); + userManager.addUser( user, "jc" ); + addDefaultGrantUserGroupRole( user ); + userManager.authenticate( user, "jc" ); + try + { + userManager.authenticate( user, "JC" ); + fail( "should have thrown PasswordMismatchException" ); + } + catch ( PasswordMismatchException pme ) + { + // good + } + } + + @Test + public void testChangePassword() + throws Exception + { + user = userManager.getUserInstance( "Jonathan" ); + userManager.addUser( user, "jc" ); + addDefaultGrantUserGroupRole( user ); + try + { + userManager.changePassword( user, "WrongPWD", "JC" ); + fail( "should have thrown PasswordMismatchException" ); + } + catch ( PasswordMismatchException pme ) + { + // good + } + userManager.changePassword( user, "jc", "JC" ); + userManager.authenticate( user, "JC" ); + } + + @Test + public void testForcePassword() + throws Exception + { + user = userManager.getUserInstance( "Connor" ); + userManager.addUser( user, "jc_subset" ); + addDefaultGrantUserGroupRole( user ); + + userManager.forcePassword( user, "JC_SUBSET" ); + userManager.authenticate( user, "JC_SUBSET" ); + } + + /* + * Class to test for User getUserInstance() + */ + @Test + public void testGetUserInstance() + throws Exception + { + user = userManager.getUserInstance(); + assertNotNull( user ); + assertTrue( user.getName() == null ); + } + + /* + * Class to test for User getUserInstance(String) + */ + @Test + public void testGetUserInstanceString() + throws Exception + { + user = userManager.getUserInstance( "Philip" ); + assertEquals( "philip", user.getName() ); + } + + /** + * Need to figure out if save is something we want.. right now it just bloes up if you actually change anything. + * + * @todo figur out what to do here... + * @throws Exception + */ + @Test + public void testSaveUser() + throws Exception + { + user = userManager.getUserInstance( "Kate" ); + userManager.addUser( user, "katiedid" ); + + addDefaultGrantUserGroupRole( user ); + + user = userManager.getUser( user.getName() ); + // user.setName("Katherine"); + userManager.saveUser( user ); + assertEquals( "kate", userManager.getUser( user.getName() ).getName() ); + } + + @Test + public void testGetACL() + throws Exception + { + user = userManager.getUserInstance( "Tony" ); + userManager.addUser( user, "california" ); + addDefaultGrantUserGroupRole( user ); + + AccessControlList acl = userManager.getACL( user ); + + assertNotNull( acl ); + + Role testRole = securityService.getRoleManager().getRoleByName( TEST_ROLE ); + Group testGroup = securityService.getGroupManager().getGroupByName( TEST_GROUP ); + assertTrue( ( (TurbineAccessControlList) acl ).hasRole( testRole, testGroup ) ); + + Group globalGroup = securityService.<TurbineModelManager> getModelManager().getGlobalGroup(); + securityService.<TurbineModelManager> getModelManager().grant( user, globalGroup, testRole ); + // immutable + acl = userManager.getACL( user ); + + assertTrue( ( (TurbineAccessControlList) acl ).hasRole( testRole ) ); + } + + @Test + public void testRemoveUser() + throws Exception + { + user = userManager.getUserInstance( "Rick" ); + userManager.addUser( user, "nb" ); + addDefaultGrantUserGroupRole( user ); + // required + revokeDefaultGrantUserGroupRole( user ); + userManager.removeUser( user ); + try + { + User user2 = userManager.getUser( user.getName() ); + fail( "Should have thrown UEE" ); + } + catch ( UnknownEntityException uee ) + { + // good + } + } + + @Test + public void testAddUser() + throws Exception + { + user = userManager.getUserInstance( "Joe1" ); + assertNull( user.getId() ); + userManager.addUser( user, "mc" ); + addDefaultGrantUserGroupRole( user ); + user = userManager.getUserInstance( "Joe2" ); + assertNull( user.getId() ); + userManager.addUser( user, "mc" ); + assertNotNull( user.getId() ); + assertNotNull( userManager.getUser( user.getName() ) ); + } + + /* + * Class to test for boolean checkExists(string) + */ + public void testAddUserTwiceFails() + throws Exception + { + user = userManager.getUserInstance( "EATLUNCH" ); + userManager.addUser( user, "bob" ); + addDefaultGrantUserGroupRole( user ); + assertTrue( userManager.checkExists( user.getName() ) ); + User user2 = userManager.getUserInstance( "EATLUNCH" ); + try + { + userManager.addUser( user2, "bob" ); + } + catch ( EntityExistsException uee ) + { + // good + } + try + { + userManager.addUser( user2, "differentpassword" ); + } + catch ( EntityExistsException uee ) + { + // good + } + } + + @Test + public void testCheckUserCaseSensitiveExists() + throws Exception + { + user = userManager.getUserInstance( "borrisJohnson" ); + userManager.addUser( user, "bob" ); + + assertTrue( userManager.checkExists( "borrisJohnson" ) ); + } + + private void addDefaultGrantUserGroupRole( User user ) + throws Exception + { + securityService.<TurbineModelManager> getModelManager().grant( user, group, role ); + 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 ) ); + } + + private void revokeDefaultGrantUserGroupRole( User user ) + throws Exception + { + securityService.<TurbineModelManager> getModelManager().revoke( user, group, role ); + boolean ugrFound = false; + for ( TurbineUserGroupRole ugr : ( (TurbineUser) user ).getUserGroupRoleSet() ) + { + if ( ugr.getUser().equals( user ) && ugr.getGroup().equals( group ) && ugr.getRole().equals( role ) ) + { + ugrFound = true; + break; + } + } + ; + assertFalse( ugrFound ); + } + +}
