gvSIG projects pool

package org.gvsig.vcsgis.lib.impl;

import java.io.File;

import java.util.List;

import junit.framework.TestCase;

import static junit.framework.TestCase.assertEquals;

import static junit.framework.TestCase.assertNotNull;

import org.apache.commons.io.FileUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.fmap.dal.feature.EditableFeature;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.store.jdbc2.JDBCServerExplorer;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

import org.gvsig.vcsgis.lib.VCSGisEntity;

import org.gvsig.vcsgis.lib.VCSGisLocator;

import org.gvsig.vcsgis.lib.VCSGisManager;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_NO_ERROR;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_OK;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_USER_NOT_AUTHORIZED;

import org.gvsig.vcsgis.lib.VCSGisUserIdentificationRequester;

import org.gvsig.vcsgis.lib.repository.VCSGisRepository;

import org.gvsig.vcsgis.lib.repository.VCSGisRepositoryChange;

import org.gvsig.vcsgis.lib.repository.localdb.VCSGisRepositoryLocaldb;

import org.gvsig.vcsgis.lib.repository.localdb.tables.ConfigRepoTable;

import org.gvsig.vcsgis.lib.repository.localdb.tables.DataRepoTable;

import org.gvsig.vcsgis.lib.repository.localdb.tables.EntitiesRepoTable;

import org.gvsig.vcsgis.lib.repository.localdb.tables.UsersRepoTable;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspace;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspaceChanges;

import org.gvsig.vcsgis.lib.workspace.tables.WorkspaceChangesTable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class Test19Authorization extends TestCase {

    private static final Logger LOGGER = LoggerFactory.getLogger(Test19Authorization.class);

    public Test19Authorization(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    private void check(FeatureStore store2, String relatedFeatureCode, int id, String text) throws Exception {

        Feature f = store2.findFirst("VCSGISCODE = '"+relatedFeatureCode+"'");

        assertEquals(id, f.getInt("id"));

        assertEquals(text, f.getString("text"));

    }

    // TODO add test methods here. The name must begin with 'test'. For example:

    // public void testHello() {}

    public void testAuthorizationAllAllowed() throws Exception {

        final String testid = "AuthorizationAllAllowed";

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        JDBCServerExplorer server = TestUtils.openServerExplorer("srv-"+testid);

        File wsfile = TestUtils.getFile(FileUtils.getFile("test-dbs","ws-"+testid)); 

        File ws2file = TestUtils.getFile(FileUtils.getFile("test-dbs","ws2-"+testid)); 

        Feature f;

        EditableFeature ef;

        List<Feature> features;

        FeatureStore sourceTest;

        FeatureStore store2;

        // ---------------------------------------------------------

        // Creamos el respositorio y lo abrimos.

        int r = manager.initRepository(server.getParameters(), null);

        assertEquals("srv-init status", 0, r);

        VCSGisRepository repo = manager.openRepository(server.getParameters());

        TestUtils.h2sql_repository(repo);

        enableAuthentication(repo);

        addUser(repo, "user1", "password","add,entities,commit,update,checkout,history,topologyplans,users");

        // ---------------------------------------------------------

        // Creamos un workspace y lo abrimos.

        r = manager.initWorkspace(wsfile, repo, "Test add and commit",null);

        assertEquals("ws-init status", 0, r);

        VCSGisWorkspace ws1 = manager.openWorkspace(wsfile);

        TestUtils.h2sql_workspace(ws1);

        ws1.setUserIdentificationRequester(getIdentificationRequester("user1", "password"));

        // ---------------------------------------------------------

        // Adicionamos al workspace la tabla de pruebas y lo commitamos

        sourceTest = TestUtils.openSourceStore2();

        r = ws1.add("test", sourceTest, "text");

        assertEquals("ws-add status", 0, r);

        r = ws1.commit();

        assertEquals("ws-commit status", ERR_OK, r);

        enableAuthorizationByEntity(repo, "test");

        // ---------------------------------------------------------

        // Comprobamos que tras el commit la tabla de cambios esta vacia.

        FeatureStore changesStore = ws1.getFeatureStore(WorkspaceChangesTable.TABLE_NAME);

        assertEquals("Changes", 0, changesStore.size64());

        DisposeUtils.disposeQuietly(changesStore);

        // ---------------------------------------------------------

        // Comprobamos que la tabla adicionada al espacio ed trabajo contiene

        // los mismos registros que la original.

        FeatureStore dataStore = ((VCSGisRepositoryLocaldb)repo).getFeatureStore(DataRepoTable.TABLE_NAME);

        assertEquals("DataStore", sourceTest.size64(), dataStore.size64());

        sourceTest.dispose();

        DisposeUtils.disposeQuietly(dataStore);

        // ------------------------------------------------------------

        // Inicializamos el workspace2 asociandolo al mismo repositorio que 

        // workspace1 y lo abrimos.

        r = manager.initWorkspace(ws2file, repo, "Test update2",null);

        assertEquals("init_ws2 status", ERR_NO_ERROR, r);

        VCSGisWorkspace ws2 = manager.openWorkspace(ws2file);

        TestUtils.h2sql_workspace(ws2);

        ws2.setUserIdentificationRequester(getIdentificationRequester("user1", "password"));

        // ------------------------------------------------------------

        // Hacemos un checkout en workspace2 de la tabla "test" 

        // y comprobamos que tiene lo que toca.

        r = ws2.checkout("test");

        assertEquals("ws2-checkout status", ERR_NO_ERROR, r);

        VCSGisEntity entity = ws2.getWorkspaceEntityByName("test");

        assertNotNull("ws2.update-1 entity", entity);

        assertEquals("ws2.update-1 label", "text", entity.getFieldForLabel());

        store2 = ws2.getFeatureStore("test");

        assertEquals("ws2-checkout sizes", 3, store2.size64());

        features = store2.getFeatures((Expression)null, "id", true);

        assertEquals(1    , features.get(0).getInt("id"));

        assertEquals("AAA", features.get(0).getString("text"));

        assertEquals(2    , features.get(1).getInt("id"));

        assertEquals("BBB", features.get(1).getString("text"));

        assertEquals(3    , features.get(2).getInt("id"));

        assertEquals("CCC", features.get(2).getString("text"));

        DisposeUtils.disposeQuietly(store2);

        // ------------------------------------------------------------

        // Modificamos la tabla "test" en el workspace1 y la commitamos.

        sourceTest = ws1.getFeatureStore("test");

        sourceTest.edit();

        f = sourceTest.findFirst("id=2");

        ef = f.getEditable();

        ef.set("text", "BB2");

        sourceTest.update(ef);

        ef = sourceTest.createNewFeature();

        ef.set("id",4);

        ef.set("text","DDD");

        sourceTest.insert(ef);

        sourceTest.finishEditing();

        DisposeUtils.disposeQuietly(sourceTest);

        r = ws1.commit();

        assertEquals("ws1.commit-2 status", ERR_NO_ERROR, r);

        // ------------------------------------------------------------

        // Actualizamos (update) la tabla "test" en el workspace2 

        // y comprobamos que tiene lo que toca.

        r = ws2.updatePrepare("test");

        assertEquals("ws2.update-prepare-1 status", 0, r);

        VCSGisWorkspaceChanges<VCSGisRepositoryChange> remoteChanges = ws2.getRemoteChanges();

        assertEquals("ws2.update-prepare-1 remoteChanges size", 2L, remoteChanges.size64());

        r = ws2.updatePrepare("test");

        assertEquals("ws2.updatePrepare-1 status", 0, r);

        r = ws2.update("test");

        assertEquals("ws2.update-1 status", 0, r);

        store2 = ws2.getFeatureStore("test");

        assertEquals("ws2-upfate sizes", 4, store2.size64());

        features = store2.getFeatures((Expression)null, "id", true);

        assertEquals(1    , features.get(0).getInt("id"));

        assertEquals("AAA", features.get(0).getString("text"));

        assertEquals(2    , features.get(1).getInt("id"));

        assertEquals("BB2", features.get(1).getString("text"));

        assertEquals(3    , features.get(2).getInt("id"));

        assertEquals("CCC", features.get(2).getString("text"));

        assertEquals(4    , features.get(3).getInt("id"));

        assertEquals("DDD", features.get(3).getString("text"));

        DisposeUtils.disposeQuietly(store2);

    }

    public void testAuthorizationUserCommitNotAllowed() throws Exception {

        final String testid = "AuthorizationUserCommitNotAllowed";

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        JDBCServerExplorer server = TestUtils.openServerExplorer("srv-"+testid);

        File wsfile = TestUtils.getFile(FileUtils.getFile("test-dbs","ws-"+testid)); 

        // ---------------------------------------------------------

        // Creamos el respositorio y lo abrimos.

        int r = manager.initRepository(server.getParameters(), null);

        assertEquals("srv-init status", 0, r);

        VCSGisRepository repo = manager.openRepository(server.getParameters());

        TestUtils.h2sql_repository(repo);

        enableAuthentication(repo);

        //All allowed except commit

        addUser(repo, "user1", "password","add,entities,update,checkout,history,topologyplans,users");

        // ---------------------------------------------------------

        // Creamos un workspace y lo abrimos.

        r = manager.initWorkspace(wsfile, repo, "Test add and commit",null);

        assertEquals("ws-init status", 0, r);

        VCSGisWorkspace ws = manager.openWorkspace(wsfile);

        TestUtils.h2sql_workspace(ws);

        ws.setUserIdentificationRequester(getIdentificationRequester("user1", "password"));

        // ---------------------------------------------------------

        // Adicionamos al workspace la tabla de pruebas y lo commitamos

        FeatureStore sourceStore = TestUtils.openSourceStore1();

        r = ws.add("test", sourceStore, "ID");

        assertEquals("ws-add status", 0, r);

        // Intentamos el commit y comprobamos que no está permitido

        r = ws.commit();

        assertEquals("ws-commit status", ERR_USER_NOT_AUTHORIZED, r);

    }

    public void testAuthorizationCheckoutNotAllowed() throws Exception {

        final String testid = "AuthorizationCheckoutNotAllowed";  ///********************************************

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        JDBCServerExplorer server = TestUtils.openServerExplorer("srv-"+testid);

        File wsfile = TestUtils.getFile(FileUtils.getFile("test-dbs","ws-"+testid)); 

        File ws2file = TestUtils.getFile(FileUtils.getFile("test-dbs","ws2-"+testid)); 

        Feature f;

        EditableFeature ef;

        List<Feature> features;

        FeatureStore sourceTest;

        FeatureStore store2;

        // ---------------------------------------------------------

        // Creamos el respositorio y lo abrimos.

        int r = manager.initRepository(server.getParameters(), null);

        assertEquals("srv-init status", 0, r);

        VCSGisRepository repo = manager.openRepository(server.getParameters());

        TestUtils.h2sql_repository(repo);

        enableAuthentication(repo);

        addUser(repo, "user1", "password","add,entities,commit,update,checkout,history,topologyplans,users");

        addUser(repo, "user2", "password","add,entities,commit,update,history,topologyplans,users");

        // ---------------------------------------------------------

        // Creamos un workspace y lo abrimos.

        r = manager.initWorkspace(wsfile, repo, "Test add and commit",null);

        assertEquals("ws-init status", 0, r);

        VCSGisWorkspace ws1 = manager.openWorkspace(wsfile);

        TestUtils.h2sql_workspace(ws1);

        ws1.setUserIdentificationRequester(getIdentificationRequester("user1", "password"));

        // ---------------------------------------------------------

        // Adicionamos al workspace la tabla de pruebas y lo commitamos

        sourceTest = TestUtils.openSourceStore2();

        r = ws1.add("test", sourceTest, "text");

        assertEquals("ws-add status", 0, r);

        r = ws1.commit();

        assertEquals("ws-commit status", ERR_OK, r);

        enableAuthorizationByEntity(repo, "test");

        // ---------------------------------------------------------

        // Comprobamos que tras el commit la tabla de cambios esta vacia.

        FeatureStore changesStore = ws1.getFeatureStore(WorkspaceChangesTable.TABLE_NAME);

        assertEquals("Changes", 0, changesStore.size64());

        DisposeUtils.disposeQuietly(changesStore);

        // ---------------------------------------------------------

        // Comprobamos que la tabla adicionada al espacio ed trabajo contiene

        // los mismos registros que la original.

        FeatureStore dataStore = ((VCSGisRepositoryLocaldb)repo).getFeatureStore(DataRepoTable.TABLE_NAME);

        assertEquals("DataStore", sourceTest.size64(), dataStore.size64());

        sourceTest.dispose();

        DisposeUtils.disposeQuietly(dataStore);

        // ------------------------------------------------------------

        // Inicializamos el workspace2 asociandolo al mismo repositorio que 

        // workspace1 y lo abrimos.

        r = manager.initWorkspace(ws2file, repo, "Test update2",null);

        assertEquals("init_ws2 status", ERR_NO_ERROR, r);

        VCSGisWorkspace ws2 = manager.openWorkspace(ws2file);

        TestUtils.h2sql_workspace(ws2);

        ws2.setUserIdentificationRequester(getIdentificationRequester("user2", "password"));

        // ------------------------------------------------------------

        // Hacemos un checkout en workspace2 de la tabla "test" 

        // y comprobamos que tiene lo que toca.

        r = ws2.checkout("test");

        assertEquals("ws2-checkout status", ERR_USER_NOT_AUTHORIZED, r);

        VCSGisEntity entity = ws2.getWorkspaceEntityByName("test");

        assertNull("ws2.update-1 entity", entity);

    }

    public void testAuthorizationCommitByEntityNotAllowed() throws Exception {

        final String testid = "AuthorizationCommitByEntityNotAllowed";

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        JDBCServerExplorer server = TestUtils.openServerExplorer("srv-"+testid);

        File wsfile = TestUtils.getFile(FileUtils.getFile("test-dbs","ws-"+testid)); 

        File ws2file = TestUtils.getFile(FileUtils.getFile("test-dbs","ws2-"+testid)); 

        Feature f;

        EditableFeature ef;

        List<Feature> features;

        FeatureStore sourceTest;

        FeatureStore store2;

        // ---------------------------------------------------------

        // Creamos el respositorio y lo abrimos.

        int r = manager.initRepository(server.getParameters(), null);

        assertEquals("srv-init status", 0, r);

        VCSGisRepository repo = manager.openRepository(server.getParameters());

        TestUtils.h2sql_repository(repo);

        enableAuthentication(repo);

        addUser(repo, "user1", "password","add,entities,commit,update,checkout,history,topologyplans,users");

        addUser(repo, "user2", "password","add,entities,commit,update,checkout,history,topologyplans,users");

        // ---------------------------------------------------------

        // Creamos un workspace y lo abrimos.

        r = manager.initWorkspace(wsfile, repo, "Test add and commit",null);

        assertEquals("ws-init status", 0, r);

        VCSGisWorkspace ws1 = manager.openWorkspace(wsfile);

        TestUtils.h2sql_workspace(ws1);

        ws1.setUserIdentificationRequester(getIdentificationRequester("user1", "password"));

        // ---------------------------------------------------------

        // Adicionamos al workspace la tabla de pruebas y lo commitamos

        sourceTest = TestUtils.openSourceStore2();

        r = ws1.add("test", sourceTest, "text");

        assertEquals("ws-add status", 0, r);

        r = ws1.commit();

        assertEquals("ws-commit status", ERR_OK, r);

        enableAuthorizationByEntity(repo, "test");

        // ---------------------------------------------------------

        // Comprobamos que tras el commit la tabla de cambios esta vacia.

        FeatureStore changesStore = ws1.getFeatureStore(WorkspaceChangesTable.TABLE_NAME);

        assertEquals("Changes", 0, changesStore.size64());

        DisposeUtils.disposeQuietly(changesStore);

        // ---------------------------------------------------------

        // Comprobamos que la tabla adicionada al espacio de trabajo contiene

        // los mismos registros que la original.

        FeatureStore dataStore = ((VCSGisRepositoryLocaldb)repo).getFeatureStore(DataRepoTable.TABLE_NAME);

        assertEquals("DataStore", sourceTest.size64(), dataStore.size64());

        sourceTest.dispose();

        DisposeUtils.disposeQuietly(dataStore);

        // ------------------------------------------------------------

        // Inicializamos el workspace2 asociandolo al mismo repositorio que 

        // workspace1 y lo abrimos.

        r = manager.initWorkspace(ws2file, repo, "Test update2",null);

        assertEquals("init_ws2 status", ERR_NO_ERROR, r);

        VCSGisWorkspace ws2 = manager.openWorkspace(ws2file);

        TestUtils.h2sql_workspace(ws2);

        ws2.setUserIdentificationRequester(getIdentificationRequester("user2", "password"));

        // ------------------------------------------------------------

        // Hacemos un checkout en workspace2 de la tabla "test" 

        // y comprobamos que tiene lo que toca.

        r = ws2.checkout("test");

        assertEquals("ws2-checkout status", ERR_NO_ERROR, r);

        VCSGisEntity entity = ws2.getWorkspaceEntityByName("test");

        assertNotNull("ws2.update-1 entity", entity);

        assertEquals("ws2.update-1 label", "text", entity.getFieldForLabel());

        store2 = ws2.getFeatureStore("test");

        assertEquals("ws2-checkout sizes", 3, store2.size64());

        features = store2.getFeatures((Expression)null, "id", true);

        assertEquals(1    , features.get(0).getInt("id"));

        assertEquals("AAA", features.get(0).getString("text"));

        assertEquals(2    , features.get(1).getInt("id"));

        assertEquals("BBB", features.get(1).getString("text"));

        assertEquals(3    , features.get(2).getInt("id"));

        assertEquals("CCC", features.get(2).getString("text"));

        DisposeUtils.disposeQuietly(store2);

        // ------------------------------------------------------------

        // Modificamos la tabla "test" en el workspace2, la commitamos y comprobamos que no hay permisos para hacerlo.

        sourceTest = ws2.getFeatureStore("test");

        sourceTest.edit();

        f = sourceTest.findFirst("id=2");

        ef = f.getEditable();

        ef.set("text", "BB2");

        sourceTest.update(ef);

        ef = sourceTest.createNewFeature();

        ef.set("id",4);

        ef.set("text","DDD");

        sourceTest.insert(ef);

        sourceTest.finishEditing();

        DisposeUtils.disposeQuietly(sourceTest);

        r = ws2.commit();

        assertEquals("ws2.commit-1 status", ERR_USER_NOT_AUTHORIZED, r);

        DisposeUtils.disposeQuietly(store2);

    }

    private void enableAuthentication(VCSGisRepository repo){

        ConfigRepoTable varsTable = new ConfigRepoTable();

        varsTable.set((VCSGisRepositoryLocaldb) repo, "AUTHENTICATION", String.valueOf(true));

        varsTable.set((VCSGisRepositoryLocaldb) repo, "AUTHORIZATION", String.valueOf(true));

    }

    private void addUser(VCSGisRepository repo, String userId, String password, String roles) {

        UsersRepoTable.UserRepoRow userRow = new UsersRepoTable.UserRepoRow((VCSGisRepositoryLocaldb) repo);

        userRow.setIdentifier(userId);

        userRow.setPassword(password);

        userRow.setAllowedOperations(roles);

        userRow.insert();

    }

    private void enableAuthorizationByEntity(VCSGisRepository repo, String entityName){

        EntitiesRepoTable table = new EntitiesRepoTable();

        EntitiesRepoTable.EntityRepoRow entityRow = table.getByEntityName((VCSGisRepositoryLocaldb) repo, entityName);

        entityRow.setAuthorizations("{"

                + "  \"entities\": [ \"user1\", \"user2\"],"

                + "  \"commit\": [ \"user1\" ],"

                + "  \"update\": [ \"user1\", \"user2\"],"

                + "  \"checkout\": [ \"user1\", \"user2\"],"

                + "  \"history\": [ \"user1\" ],\n"

                + "  \"topologyplans\": [ \"user1\", \"user2\"],"

                + "  \"users\": [ \"user1\", \"user2\"]"

                + "}");

        entityRow.update();

    }

    VCSGisUserIdentificationRequester getIdentificationRequester(String userId, String password) {

        return new VCSGisUserIdentificationRequester() {

            int retries = 0;

            @Override

            public boolean requestIdentification() {

                if(retries++ > 5){

                    return false;

                }

                return true;

            }

            @Override

            public String getUserId() {

                return userId;

            }

            @Override

            public String getPassword() {

                return password;

            }

        };

    }

}