PermissionsTest.java

/*
 *   $Id$
 *
 *   Copyright 2006 University of Dundee. All rights reserved.
 *   Use is subject to license terms supplied in LICENSE.txt
 */
package ome.model.utests;

import static ome.model.internal.Permissions.Flag.UNUSED;
import static ome.model.internal.Permissions.Right.READ;
import static ome.model.internal.Permissions.Right.ANNOTATE;
import static ome.model.internal.Permissions.Right.WRITE;
import static ome.model.internal.Permissions.Role.GROUP;
import static ome.model.internal.Permissions.Role.USER;
import static ome.model.internal.Permissions.Role.WORLD;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import junit.framework.TestCase;
import ome.model.internal.Permissions;
import ome.model.internal.Permissions.Right;
import ome.model.internal.Permissions.Role;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

public class PermissionsTest extends TestCase {

    private static Logger log = LoggerFactory.getLogger(PermissionsTest.class);

    Permissions p;

    @Override
    @BeforeMethod
    protected void setUp() throws Exception {
        super.setUp();
        p = new Permissions();
    }

    @Test
    public void testSimplePermissionsAllowsEverything() throws Exception {
        assertTrue(p.isGranted(USER, READ));
        assertTrue(p.isGranted(USER, WRITE));
        assertTrue(p.isGranted(GROUP, READ));
        assertTrue(p.isGranted(GROUP, ANNOTATE));
        assertTrue(p.isGranted(GROUP, WRITE));
        assertTrue(p.isGranted(WORLD, READ));
        assertTrue(p.isGranted(WORLD, ANNOTATE));
        assertTrue(p.isGranted(WORLD, WRITE));
        // assertTrue( p.isGranted(ALL, READ) );
        // assertTrue( p.isGranted(ALL, WRITE) );
        // assertTrue( p.isGranted(ALL, USE) );
    }

    @Test
    public void testGrantAndRevokePermissions() throws Exception {
        revokeGrantCheck(USER, READ);
        revokeGrantCheck(USER, ANNOTATE);
        revokeGrantCheck(USER, WRITE);
        revokeGrantCheck(GROUP, READ);
        revokeGrantCheck(GROUP, ANNOTATE);
        revokeGrantCheck(GROUP, WRITE);
        revokeGrantCheck(WORLD, READ);
        revokeGrantCheck(WORLD, ANNOTATE);
        revokeGrantCheck(WORLD, WRITE);
    }

    @Test
    public void testNullRightsAreOk() throws Exception {
        String before;

        before = p.toString();
        p.grant(USER, (Right[]) null);
        assertEquals(before, p.toString());

        before = p.toString();
        p.grant(USER);
        assertEquals(before, p.toString());

        before = p.toString();
        p.revoke(USER, (Right[]) null);
        assertEquals(before, p.toString());

        before = p.toString();
        p.revoke(USER);
        assertEquals(before, p.toString());
    }

    @Test
    public void testVarArgs() throws Exception {
        p.revoke(GROUP, READ, WRITE);
        assertFalse(p.isGranted(GROUP, READ));
        assertFalse(p.isGranted(GROUP, WRITE));
    }

    @Test
    public void testApplyMask() throws Exception {
        Permissions mask = new Permissions();
        mask.revoke(WORLD, WRITE);
        assertFalse(mask.isGranted(WORLD, WRITE));

        p.revokeAll(mask);
        assertFalse(p.isGranted(WORLD, WRITE));

        mask = new Permissions(Permissions.EMPTY);
        mask.grant(USER, READ);
        assertTrue(mask.isGranted(USER, READ));

        p.grantAll(mask);
        assertTrue(p.isGranted(USER, READ));

    }

    // ~ Testing immutability
    // =========================================================================

    @Test(expectedExceptions = UnsupportedOperationException.class)
    public void testRevokeOnImmutable() throws Exception {
        Permissions.READ_ONLY.revoke(GROUP, READ);
    }

    @Test(expectedExceptions = UnsupportedOperationException.class)
    public void testGrantOnImmutable() throws Exception {
        Permissions.READ_ONLY.grant(GROUP, WRITE);
    }

    @Test(expectedExceptions = UnsupportedOperationException.class)
    public void testRevokeAllOnImmutable() throws Exception {
        Permissions.READ_ONLY.revokeAll(Permissions.GROUP_PRIVATE);
    }

    @Test(expectedExceptions = UnsupportedOperationException.class)
    public void testGrantAllOnImmutable() throws Exception {
        Permissions.READ_ONLY.grantAll(Permissions.GROUP_PRIVATE);
    }

    @Test
    public void testCopyConstructor() throws Exception {
        Permissions p1 = new Permissions();
        p1.revoke(GROUP, WRITE);
        assertFalse(p1.isGranted(GROUP, WRITE));
        Permissions p2 = new Permissions(p1);
        assertFalse(p2.isGranted(GROUP, WRITE));

        Permissions none = new Permissions(Permissions.EMPTY);
        assertFalse(none.isGranted(USER, READ));
        assertFalse(none.isGranted(USER, WRITE));
        assertFalse(none.isGranted(GROUP, READ));
        assertFalse(none.isGranted(GROUP, WRITE));
        assertFalse(none.isGranted(WORLD, READ));
        assertFalse(none.isGranted(WORLD, WRITE));

    }

    // ~ Internal-state dependent tests
    // =========================================================================

    private static class Perms extends Permissions {
        /**
         * 
         */
        private static final long serialVersionUID = -181330578094652586L;

        public long toLong() {
            return super.getPerm1();
        }

        @Override
        public Perms revoke(Role role, Right... rights) {
            return (Perms) super.revoke(role, rights);
        }
    }

    @Test
    public void testLongValues() throws Exception {
        Perms pp = new Perms();
        assertEquals(pp.toLong(), -1);
        pp.revoke(GROUP, WRITE);
        pp.revoke(WORLD, WRITE);
        assertEquals(pp.toLong(), -35);
    }

    @Test
    public void testToBits() throws Exception {
        bitCompare(USER, READ);
        bitCompare(USER, WRITE);
        bitCompare(GROUP, READ);
        bitCompare(GROUP, WRITE);
        bitCompare(WORLD, READ);
        bitCompare(WORLD, WRITE);
    }

    // ~ Equals && HashCode
    // =========================================================================
    // see http://trac.openmicroscopy.org.uk/ome/ticket/291

    @Test(groups = "ticket:291")
    public void testEquals() throws Exception {
        Permissions t = new Permissions();
        // assertEquals(p,t);
        assertTrue(p.identical(t));

        p.revoke(GROUP, READ);
        t.revoke(GROUP, READ);
        // assertEquals(p,t);
        assertTrue(p.identical(t));
    }

    @Test(groups = "ticket:291")
    public void testHashCode() throws Exception {
        Permissions t = new Permissions();
        // assertEquals(p.hashCode(),t.hashCode());
        assertFalse(p.hashCode() == t.hashCode());

        p.revoke(GROUP, WRITE);
        t.revoke(GROUP, WRITE);
        // assertEquals(p.hashCode(),t.hashCode());
        assertFalse(p.hashCode() == t.hashCode());
    }

    @Test(groups = "ticket:291")
    public void testSameRights() throws Exception {
        Permissions t = new Permissions();
        p.revoke(GROUP, WRITE);
        t.revoke(GROUP, WRITE);
        assertTrue(p.sameRights(t));
    }

    // ~ Flags
    // =========================================================================

    @Test(groups = "ticket:182")
    public void testFlags() throws Exception {
        Permissions t = new Permissions();
        assertFalse(t.isSet(UNUSED));
        t.set(UNUSED);
        assertTrue(t.isSet(UNUSED));
    }

    @Test(groups = "ticket:215")
    public void testCopyCtorCopiesFlags() throws Exception {
        p = new Permissions();
        assertFalse(p.isSet(UNUSED));
        p.set(UNUSED);
        Permissions t = new Permissions(p);
        assertTrue(t.isSet(UNUSED));

    }

    // ~ Immutables
    // =========================================================================

    @Test
    public void testRandomSample() throws Exception {
        assertFalse(Permissions.GROUP_READABLE.isGranted(WORLD, READ));
        assertTrue(Permissions.GROUP_READABLE.isGranted(GROUP, READ));
        assertTrue(Permissions.GROUP_READABLE.isGranted(USER, READ));
    }

    @Test
    public void testCompareWithString() throws Exception {
        assertTrue(Permissions.EMPTY.sameRights(Permissions
                .parseString("------")));
        assertTrue(Permissions.EMPTY.sameRights(Permissions
                .parseString("______")));
        assertTrue(Permissions.GROUP_IMMUTABLE.sameRights(Permissions
                .parseString("r_r___")));
        assertTrue(Permissions.GROUP_PRIVATE.sameRights(Permissions
                .parseString("rwrw__")));
        assertTrue(Permissions.GROUP_READABLE.sameRights(Permissions
                .parseString("rwr___")));
        assertTrue(Permissions.GROUP_WRITEABLE.sameRights(Permissions
                .parseString("rwrwr_")));
        assertTrue(Permissions.PUBLIC.sameRights(Permissions
                .parseString("rwrwrw")));
        assertTrue(Permissions.READ_ONLY.sameRights(Permissions
                .parseString("r_r_r_")));
        assertTrue(Permissions.USER_IMMUTABLE.sameRights(Permissions
                .parseString("r_____")));
        assertTrue(Permissions.USER_PRIVATE.sameRights(Permissions
                .parseString("rw____")));
        assertTrue(Permissions.USER_WRITEABLE.sameRights(Permissions
                .parseString("rwr_r_")));
        assertTrue(Permissions.WORLD_IMMUTABLE.sameRights(Permissions
                .parseString("r_r_r_")));
        assertTrue(Permissions.WORLD_WRITEABLE.sameRights(Permissions
                .parseString("rwrwrw")));

    }

    @Test
    public void testDelegationFunctionsProperly() throws Exception {
        Permissions.PUBLIC.toString();
        Permissions.PUBLIC.identical(Permissions.PUBLIC);
        Permissions.PUBLIC.isGranted(GROUP, READ);
        Permissions.PUBLIC.isSet(UNUSED);
        Permissions.PUBLIC.sameRights(p);
        try {
            Permissions.PUBLIC.grant(GROUP, READ);
        } catch (UnsupportedOperationException uoe) {
        }
        ;
        try {
            Permissions.PUBLIC.grantAll(Permissions.EMPTY);
        } catch (UnsupportedOperationException uoe) {
        }
        ;
        try {
            Permissions.PUBLIC.revoke(GROUP, READ);
        } catch (UnsupportedOperationException uoe) {
        }
        ;
        try {
            Permissions.PUBLIC.revokeAll(Permissions.EMPTY);
        } catch (UnsupportedOperationException uoe) {
        }
        ;
        try {
            Permissions.PUBLIC.set(UNUSED);
        } catch (UnsupportedOperationException uoe) {
        }
        ;
        try {
            Permissions.PUBLIC.unSet(UNUSED);
        } catch (UnsupportedOperationException uoe) {
        }
        ;
    }

    @Test
    public void testConstantsAreNotSoft() throws Exception {
        assertFalse(Permissions.EMPTY.isSet(UNUSED));
        assertFalse(Permissions.GROUP_IMMUTABLE.isSet(UNUSED));
        assertFalse(Permissions.GROUP_PRIVATE.isSet(UNUSED));
        assertFalse(Permissions.GROUP_READABLE.isSet(UNUSED));
        assertFalse(Permissions.GROUP_WRITEABLE.isSet(UNUSED));
        assertFalse(Permissions.PUBLIC.isSet(UNUSED));
        assertFalse(Permissions.READ_ONLY.isSet(UNUSED));
        assertFalse(Permissions.USER_IMMUTABLE.isSet(UNUSED));
        assertFalse(Permissions.USER_PRIVATE.isSet(UNUSED));
        assertFalse(Permissions.USER_WRITEABLE.isSet(UNUSED));
        assertFalse(Permissions.WORLD_IMMUTABLE.isSet(UNUSED));
        assertFalse(Permissions.WORLD_WRITEABLE.isSet(UNUSED));
    }

    // ~ Serialization
    // =========================================================================

    // grant() is unimplemented, until it is it will always raise this exception.
    @Test(groups = { "broken", "ticket:375" }, expectedExceptions = UnsupportedOperationException.class)
    public void testImmutableSerialization() throws Exception {
        byte[] ser = serialize(Permissions.PUBLIC);
        p = deserialize(ser);
        p.grant(GROUP, READ); // is this what we want?
    }

    // ~ Parse String
    // =========================================================================
    @Test
    public void testParseString() throws Exception {
        p = Permissions.parseString("rwrwrw");
        assertTrue(p.isGranted(USER, READ));
        assertTrue(p.isGranted(USER, ANNOTATE));
        assertTrue(p.isGranted(USER, WRITE));
        assertTrue(p.isGranted(GROUP, READ));
        assertTrue(p.isGranted(GROUP, ANNOTATE));
        assertTrue(p.isGranted(GROUP, WRITE));
        assertTrue(p.isGranted(WORLD, READ));
        assertTrue(p.isGranted(WORLD, ANNOTATE));
        assertTrue(p.isGranted(WORLD, WRITE));

        p = Permissions.parseString("RWRWRW");
        assertTrue(p.isGranted(USER, READ));
        assertTrue(p.isGranted(USER, ANNOTATE));
        assertTrue(p.isGranted(USER, WRITE));
        assertTrue(p.isGranted(GROUP, READ));
        assertTrue(p.isGranted(GROUP, ANNOTATE));
        assertTrue(p.isGranted(GROUP, WRITE));
        assertTrue(p.isGranted(WORLD, READ));
        assertTrue(p.isGranted(WORLD, ANNOTATE));
        assertTrue(p.isGranted(WORLD, WRITE));

        p = Permissions.parseString("______");
        assertFalse(p.isGranted(USER, READ));
        assertFalse(p.isGranted(USER, ANNOTATE));
        assertFalse(p.isGranted(USER, WRITE));
        assertFalse(p.isGranted(GROUP, READ));
        assertFalse(p.isGranted(GROUP, ANNOTATE));
        assertFalse(p.isGranted(GROUP, WRITE));
        assertFalse(p.isGranted(WORLD, READ));
        assertFalse(p.isGranted(WORLD, ANNOTATE));
        assertFalse(p.isGranted(WORLD, WRITE));

    }

    // ~ Private helpers
    // ===========================================================================

    private void revokeGrantCheck(Role role, Right right) {
        p.revoke(role, right);
        assertFalse(p.isGranted(role, right));
        p.grant(role, right);
        assertTrue(p.isGranted(role, right));
    }

    private void bitCompare(Role role, Right right) {
        Perms pp = new Perms().revoke(role, right);
        long l = pp.toLong();
        if (log.isDebugEnabled()) {
            log.debug(l + ":" + Long.toBinaryString(l));
        }
        long bit = Perms.bit(role, right);
        if (log.isDebugEnabled()) {
            log.debug(bit + ":" + Long.toBinaryString(bit));
        }
        assertTrue((l ^ bit) == -1L);

    }

    private Permissions deserialize(byte[] stream) throws Exception {
        ByteArrayInputStream bais;
        ObjectInputStream ois;

        bais = new ByteArrayInputStream(stream);
        ois = new ObjectInputStream(bais);
        Permissions p = (Permissions) ois.readObject();
        ois.close();
        bais.close();
        return p;
    }

    private byte[] serialize(Permissions p) throws Exception {
        ByteArrayOutputStream baos;
        ObjectOutputStream oos;

        baos = new ByteArrayOutputStream();
        oos = new ObjectOutputStream(baos);
        oos.writeObject(p);
        oos.close();
        byte[] retVal = baos.toByteArray();
        baos.close();
        return retVal;
    }
}