Package org.apache.jetspeed.security.impl

Examples of org.apache.jetspeed.security.impl.UserPrincipalImpl


        MockHttpServletRequest request = new MockHttpServletRequest();
        MockHttpServletResponse response = new MockHttpServletResponse();
        MockHttpSession session = new MockHttpSession();

//        Principal p = new UserPrincipalImpl("anotherFaker");
        Principal p = new UserPrincipalImpl(USERNAME);

        request.setUserPrincipal(p);

        request.setRemoteAddr("192.168.2.3");
        request.setSession(session);
View Full Code Here


        {
            String dn = ldap.lookupByUid(uid);

            if (!StringUtils.isEmpty(dn))
            {
                return new UserPrincipalImpl(uid);
            }
        }
        catch (SecurityException e)
        {
            logSecurityException(e, uid);
View Full Code Here

    public void testLogin() throws LoginException
    {
        loginContext.login();
        Principal found = SecurityHelper.getPrincipal(loginContext.getSubject(), UserPrincipal.class);
        assertNotNull("found principal is null", found);
        assertTrue("found principal should be anonlogin, " + found.getName(), found.getName().equals((new UserPrincipalImpl("anonlogin")).getName()));     
    }
View Full Code Here

    throws Exception
    {
        //////////////////////////////////////////////////////////////////////////
        // setup
        ////////////
        UserPrincipal adminUser = new UserPrincipalImpl("adminTEST");
        UserPrincipal userUser = new UserPrincipalImpl("userTEST");
        PortletPermission adminPerm = new PortletPermission("adminTEST::*", "view, edit");
        PortletPermission userPerm = new PortletPermission("demoTEST::*", "view, edit");
        RolePrincipal adminRole = new RolePrincipalImpl("adminTEST");
        RolePrincipal userRole = new RolePrincipalImpl("userTEST");
       
        try
        {
            ums.addUser(adminUser.getName(), "password");
            ums.addUser(userUser.getName(), "password");           
            rms.addRole(adminRole.getName());
            rms.addRole(userRole.getName());           
            rms.addRoleToUser(adminUser.getName(), adminRole.getName());
            rms.addRoleToUser(userUser.getName(), userRole.getName());
            rms.addRoleToUser(adminUser.getName(), userRole.getName());           
            pms.addPermission(adminPerm);
            pms.addPermission(userPerm);
            pms.grantPermission(adminRole, adminPerm);
            pms.grantPermission(userRole, userPerm);                       
        }
        catch (SecurityException sex)
        {
            assertTrue("failed to init testRemovePrincipalPermissions(), " + sex, false);
        }
       
        //////////////////////////////////////////////////////////////////////////
        // Run Test
        ////////////       
        Set adminPrincipals = new PrincipalsSet();
        Set adminPublicCredentials = new HashSet();
        Set adminPrivateCredentials = new HashSet();
        Set userPrincipals = new PrincipalsSet();
        Set userPublicCredentials = new HashSet();
        Set userPrivateCredentials = new HashSet();
       
        adminPrincipals.add(adminUser);
        adminPrincipals.add(adminRole);
        adminPrincipals.add(userRole);

        userPrincipals.add(userUser);
        userPrincipals.add(userRole);
       
        try
        {
            Subject adminSubject = new Subject(true, adminPrincipals, adminPublicCredentials, adminPrivateCredentials);
            Subject userSubject = new Subject(true, userPrincipals, userPublicCredentials, userPrivateCredentials);                   
           
            boolean access = pms.checkPermission(adminSubject, adminPerm);
            assertTrue("access to admin Perm should be granted to Admin ", access);
           
            access = pms.checkPermission(adminSubject, userPerm);
            assertTrue("access to user should NOT be granted to Admin ", access);

            access = pms.checkPermission(userSubject, userPerm);
            assertTrue("access to User Perm should be granted to User ", access);
           
            access = pms.checkPermission(userSubject, adminPerm);
            assertFalse("access to Admin Perm should NOT be granted to User ", access);
           
        }
        catch (AccessControlException e)
        {
            fail("failed permission check");
        }
        finally
        {
            //////////////////////////////////////////////////////////////////////////
            // cleanup
            ////////////
            try
            {
                ums.removeUser(adminUser.getName());
                ums.removeUser(userUser.getName());
                rms.removeRole(adminRole.getName());
                rms.removeRole(userRole.getName());
               
                pms.removePermission(adminPerm);
                pms.removePermission(userPerm);
View Full Code Here

    throws Exception
    {
        //////////////////////////////////////////////////////////////////////////
        // setup
        ////////////
        UserPrincipal user = new UserPrincipalImpl("test");
        PortletPermission perm1 = new PortletPermission("PortletOne", "view, edit");
        PortletPermission perm2 = new PortletPermission("PortletTwo", "view");
        PortletPermission perm3 = new PortletPermission("PortletThree", "view");
        PortletPermission perm3a = new PortletPermission("PortletThreeA", "view, edit");
        RolePrincipal role1 = new RolePrincipalImpl("Role1");
        RolePrincipal role2 = new RolePrincipalImpl("Role2");
       
        try
        {
            ums.addUser(user.getName(), "password");
            rms.addRole(role1.getName());
            rms.addRole(role2.getName());           
            rms.addRoleToUser(user.getName(), role1.getName());
            rms.addRoleToUser(user.getName(), role2.getName());
            pms.addPermission(perm1);
            pms.addPermission(perm2);
            pms.addPermission(perm3);
            pms.addPermission(perm3a);
            pms.grantPermission(user, perm1);
            pms.grantPermission(role1, perm2);                       
            pms.grantPermission(role2, perm3);           
        }
        catch (SecurityException sex)
        {
            assertTrue("failed to init testRemovePrincipalPermissions(), " + sex, false);
        }
       
        //////////////////////////////////////////////////////////////////////////
        // Run Test
        ////////////       
        Set principals = new PrincipalsSet();
        Set publicCredentials = new HashSet();
        Set privateCredentials = new HashSet();
        principals.add(user);
        principals.add(role1);
        principals.add(role2);

        try
        {
            Subject subject = new Subject(true, principals, publicCredentials, privateCredentials);       
            boolean access = pms.checkPermission(subject, perm1);
            assertTrue("access to perm1 should be granted ", access);
            access = pms.checkPermission(subject, perm2);
            assertTrue("access to perm2 should be granted ", access);
            access = pms.checkPermission(subject, perm3);
            assertTrue("access to perm3 should be granted ", access);
            access = pms.checkPermission(subject, perm3a);
            assertFalse("access to perm3a should be denied ", access);
        }
        catch (AccessControlException e)
        {
            fail("failed permission check");
        }
        finally
        {
            //////////////////////////////////////////////////////////////////////////
            // cleanup
            ////////////
            try
            {
                ums.removeUser(user.getName());
                rms.removeRole(role1.getName());
                rms.removeRole(role2.getName());           
                pms.removePermission(perm1);
                pms.removePermission(perm2);
                pms.removePermission(perm3);
View Full Code Here

     * <p>Test remove principal and associated permissions.</p>
     */
    public void testRemovePrincipalPermissions()
    {
        // Init test.
        UserPrincipal user = new UserPrincipalImpl("test");
        PortletPermission perm = new PortletPermission("anontestportlet", "view, edit");
        try
        {
            ums.addUser(user.getName(), "password");
            pms.addPermission(perm);
            pms.grantPermission(user, perm);
        }
        catch (SecurityException sex)
        {
            assertTrue("failed to init testRemovePrincipalPermissions(), " + sex, false);
        }
        try
        {
            pms.removePermissions(user);
            Permissions permissions = pms.getPermissions(user);
            assertEquals(
                "permissions should be empty for user " + user.getName(),
                0,
                (Collections.list(permissions.elements())).size());
        }
        catch (SecurityException sex)
        {
            assertTrue("could not remove permission. exception caught: " + sex, false);
        }
        // Cleanup test.
        try
        {
            ums.removeUser(user.getName());
            pms.removePermission(perm);
        }
        catch (SecurityException sex)
        {
            assertTrue("could not remove user and permission. exception caught: " + sex, false);
View Full Code Here

     * <p>Test remove permission.</p>
     */
    public void testRemovePermission()
    {
        // Init test.
        UserPrincipal user = new UserPrincipalImpl("removepermission");
        RolePrincipal role = new RolePrincipalImpl("removepermissionrole");
        PortletPermission perm1 = new PortletPermission("removepermission1", "view, edit, secure, minimized, maximized");
        PortletPermission perm2 = new PortletPermission("removepermission2", "view, edit, minimized, maximized");
        try
        {
            ums.addUser(user.getName(), "password");
            rms.addRole(role.getName());
            pms.addPermission(perm1);
            pms.addPermission(perm2);
            pms.grantPermission(user, perm1);
            pms.grantPermission(user, perm2);
            pms.grantPermission(role, perm1);
            pms.grantPermission(role, perm2);
        }
        catch (SecurityException sex)
        {
            assertTrue("failed to init testRemovePermission(), " + sex, false);
        }
        try
        {
            pms.removePermission(perm1);
            Permissions permCol1 = pms.getPermissions(new UserPrincipalImpl("removepermission"));
            assertTrue(
                "should only contain permission == {name = "
                    + perm2.getName()
                    + "}, {action = "
                    + perm2.getActions()
                    + "}, in collection of size == 1, actual size: "
                    + (Collections.list(permCol1.elements())).size(),
                validatePermissions(permCol1, perm2, 1));
            Permissions permCol2 = pms.getPermissions(new RolePrincipalImpl("removepermissionrole"));
            assertTrue(
                "should only contain permission == {name = "
                    + perm2.getName()
                    + "}, {action = "
                    + perm2.getActions()
                    + "}, in collection of size == 1, actual size: "
                    + (Collections.list(permCol2.elements())).size(),
                validatePermissions(permCol2, perm2, 1));
        }
        catch (SecurityException sex)
        {
            assertTrue("could not remove permission. exception caught: " + sex, false);
        }
        // Cleanup test.
        try
        {
            ums.removeUser(user.getName());
            pms.removePermission(perm1);
            pms.removePermission(perm2);
        }
        catch (SecurityException sex)
        {
View Full Code Here

     * <p>Test grant permission to principal.</p>
     */
    public void testGrantPermission()
    {
        // Init test.
        UserPrincipal user1 = new UserPrincipalImpl("testgrantpermission1");
        UserPrincipal user2 = new UserPrincipalImpl("testgrantpermission2");
        PortletPermission perm1 = new PortletPermission("testportlet", "view, minimized, secure");
        PortletPermission perm2 = new PortletPermission("testportlet", "view, minimized, maximized, secure");
        try
        {
            ums.addUser(user2.getName(), "password");
            pms.addPermission(perm1);
            pms.addPermission(perm2);
        }
        catch (SecurityException sex)
        {
            assertTrue("failed to init testGrantPermission(), " + sex, false);
        }

        // Test permission for new permission and new principal (does not exist).     
        try
        {
            pms.grantPermission(user1, perm1);
            assertTrue("principal does not exist. should have caught exception.", false);
        }
        catch (SecurityException sex)
        {
        }
        // Test insert new permission and existing principal.
        try
        {
            pms.grantPermission(user2, perm2);
        }
        catch (SecurityException sex)
        {
            assertTrue("principal does not exist. caught exception, " + sex, false);
        }
        Permissions permCol1 = pms.getPermissions(user2);
        assertTrue(
            "should contain permission == {name = "
                + perm2.getName()
                + "}, {action = "
                + perm2.getActions()
                + "}, in collection of size == 1, actual size: "
                + (Collections.list(permCol1.elements())).size(),
            validatePermissions(permCol1, perm2, 1));
        // Test insert duplicate permission for same principal
        try
        {
            pms.grantPermission(user2, perm2);
        }
        catch (SecurityException sex)
        {
            assertTrue("principal does not exist. caught exception, " + sex, false);
        }
        Permissions permCol2 = pms.getPermissions(user2);
        assertTrue(
            "should contain permission == {name = "
                + perm2.getName()
                + "}, {action = "
                + perm2.getActions()
                + "}, in collection of size == 1, actual size: "
                + (Collections.list(permCol2.elements())).size(),
            validatePermissions(permCol2, perm2, 1));

        // Cleanup test.
        try
        {
            ums.removeUser(user2.getName());
            pms.removePermission(perm1);
            pms.removePermission(perm2);
        }
        catch (SecurityException sex)
        {
View Full Code Here

                {
                    Iterator internalUsersIter = internalUsers.iterator();
                    while (internalUsersIter.hasNext())
                    {
                        InternalUserPrincipal internalUser = (InternalUserPrincipal) internalUsersIter.next();
                        Principal userPrincipal = new UserPrincipalImpl(UserPrincipalImpl
                                .getPrincipalNameFromFullPath(internalUser.getFullPath()));
                        if (!userPrincipals.contains(userPrincipal))
                        {
                            userPrincipals.add(userPrincipal);
                        }
View Full Code Here

                {
                    Iterator internalUsersIter = internalUsers.iterator();
                    while (internalUsersIter.hasNext())
                    {
                        InternalUserPrincipal internalUser = (InternalUserPrincipal) internalUsersIter.next();
                        Principal userPrincipal = new UserPrincipalImpl(UserPrincipalImpl
                                .getPrincipalNameFromFullPath(internalUser.getFullPath()));
                        if (!userPrincipals.contains(userPrincipal))
                        {
                            userPrincipals.add(userPrincipal);
                        }
View Full Code Here

TOP

Related Classes of org.apache.jetspeed.security.impl.UserPrincipalImpl

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.