org.jtalks.common.service.security.AclBuilderImplTest.java Source code

Introduction

Here is the source code for org.jtalks.common.service.security.AclBuilderImplTest.java

Source

/**
 * Copyright (C) 2011  JTalks.org Team
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
package org.jtalks.common.service.security;

import org.jtalks.common.model.entity.Entity;
import org.springframework.security.acls.domain.BasePermission;
import org.springframework.security.acls.domain.GrantedAuthoritySid;
import org.springframework.security.acls.domain.PrincipalSid;
import org.springframework.security.acls.model.Sid;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;

/**
 * @author Kirill Afonin
 */
public class AclBuilderImplTest {
    public static final String USERNAME = "username";
    public static final String ROLE = "ROLE_USER";
    private AclBuilder builder;
    private AclManager manager;
    private Entity target = new Entity() {
    };

    @BeforeMethod
    public void setUp() throws Exception {
        manager = mock(AclManager.class);
        builder = new AclBuilderImpl(manager, AclBuilderImpl.Action.GRANT);
    }

    @Test
    public void testUser() throws Exception {
        builder.user(USERNAME);

        assertTrue(builder.containsSid(USERNAME));
    }

    @Test
    public void testRole() throws Exception {
        builder.role(ROLE);

        assertTrue(builder.containsSid(ROLE));
    }

    @Test
    public void testNotContainsSid() {
        builder.user(USERNAME);

        assertFalse(builder.containsSid(ROLE));
    }

    @Test
    public void testNotContainsUser() {
        builder.role(ROLE);

        assertFalse(builder.containsSid(USERNAME));
    }

    @Test
    public void testAdmin() throws Exception {
        builder.admin();

        assertTrue(builder.hasPermission(BasePermission.ADMINISTRATION));
    }

    @Test
    public void testRead() throws Exception {
        builder.read();

        assertTrue(builder.hasPermission(BasePermission.READ));
    }

    @Test
    public void testWrite() throws Exception {
        builder.write();

        assertTrue(builder.hasPermission(BasePermission.WRITE));
    }

    @Test
    public void testDelete() throws Exception {
        builder.delete();

        assertTrue(builder.hasPermission(BasePermission.DELETE));
    }

    @Test
    public void testCreate() throws Exception {
        builder.create();

        assertTrue(builder.hasPermission(BasePermission.CREATE));
    }

    @Test
    public void testGrantOn() throws Exception {
        builder.user(USERNAME).admin().on(target);

        assertFalse(builder.containsSid(USERNAME));
        assertFalse(builder.hasPermission(BasePermission.ADMINISTRATION));
        verify(manager).grant(builder.getSids(), builder.getPermissions(), target);
    }

    @Test
    public void testRemoveOn() throws Exception {
        builder = new AclBuilderImpl(manager, AclBuilderImpl.Action.DELETE);

        builder.user(USERNAME).admin().on(target);

        assertFalse(builder.containsSid(USERNAME));
        assertFalse(builder.hasPermission(BasePermission.ADMINISTRATION));
        verify(manager).delete(builder.getSids(), builder.getPermissions(), target);
    }

    @Test
    public void testRevokeOn() {
        builder = new AclBuilderImpl(manager, AclBuilderImpl.Action.REVOKE);
        builder.user(USERNAME).read().on(target);

        assertFalse(builder.containsSid(USERNAME));
        verify(manager).revoke(builder.getSids(), builder.getPermissions(), target);
    }

    @Test
    public void testGrantToTwoSids() {
        builder.user(USERNAME).role(ROLE);

        assertTrue(builder.containsSid(ROLE));
        assertTrue(builder.containsSid(USERNAME));
        for (Sid sid : builder.getSids()) {
            assertTrue((sid instanceof GrantedAuthoritySid) || (sid instanceof PrincipalSid));
        }
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public void testOnWithoutSids() {
        builder.admin().on(target);
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public void testOnWithoutPermissions() {
        builder.user(USERNAME).on(target);
    }

    @Test(expectedExceptions = IllegalStateException.class)
    public void testOnWithoutSidsAndPermissions() {
        builder.on(target);
    }
}