gvSIG projects pool

package org.gvsig.vcsgis.lib.impl;

import java.io.File;

import java.util.List;

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.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.VCSGisRepositoryLocaldbImpl;

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;

public abstract class AbstractTest19Authorization extends AbstractTestVCSGIS {

    public AbstractTest19Authorization(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

    }

    @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() {}

    protected void testAuthorizationAllAllowed() throws Exception {

        utils().cleanRepositoryDatabase();

        final String testid = "AuthorizationAllAllowed";

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        JDBCServerExplorer server = utils().openRepositoryServerExplorer("srv-"+testid);

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

        File ws2file = utils().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());

        utils().info_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);

        utils().info_workspace(ws1);

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

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

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

        sourceTest = utils().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 = ((VCSGisRepositoryLocaldbImpl)repo).getFeatureStore(DataRepoTable.TABLE_NAME, true);

        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);

        utils().info_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.openFeatureStore("test", true);

        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.openFeatureStore("test",false);

        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.openFeatureStore("test",false);

        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);

    }

    protected void testAuthorizationUserCommitNotAllowed() throws Exception {

        try {

            utils().cleanRepositoryDatabase();

            final String testid = "AuthorizationUserCommitNotAllowed";

            VCSGisManager manager = VCSGisLocator.getVCSGisManager();

            JDBCServerExplorer server = utils().openRepositoryServerExplorer("srv-"+testid);

            File wsfile = utils().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());

            utils().info_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);

            utils().info_workspace(ws);

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

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

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

            FeatureStore sourceStore = utils().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);

        } catch(Exception ex) {

            LOGGER.warn("",ex);

            throw ex;

        }

    }

    protected void testAuthorizationCheckoutNotAllowed() throws Exception {

        try {

            utils().cleanRepositoryDatabase();

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

            VCSGisManager manager = VCSGisLocator.getVCSGisManager();

            JDBCServerExplorer server = utils().openRepositoryServerExplorer("srv-"+testid);

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

            File ws2file = utils().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());

            utils().info_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);

            utils().info_workspace(ws1);

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

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

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

            sourceTest = utils().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 = ((VCSGisRepositoryLocaldbImpl)repo).getFeatureStore(DataRepoTable.TABLE_NAME, true);

            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);

            utils().info_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);

        } catch(Exception ex) {

            LOGGER.warn("",ex);

            throw ex;

        }

    }

    protected void testAuthorizationCommitByEntityNotAllowed() throws Exception {

        utils().cleanRepositoryDatabase();

        final String testid = "AuthorizationCommitByEntityNotAllowed";

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        JDBCServerExplorer server = utils().openRepositoryServerExplorer("srv-"+testid);

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

        File ws2file = utils().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());

        utils().info_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);

        utils().info_workspace(ws1);

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

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

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

        sourceTest = utils().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 = ((VCSGisRepositoryLocaldbImpl)repo).getFeatureStore(DataRepoTable.TABLE_NAME, true);

        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);

        utils().info_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.openFeatureStore("test", true);

        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.openFeatureStore("test",false);

        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((VCSGisRepositoryLocaldbImpl) repo, "AUTHENTICATION", String.valueOf(true));

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

    }

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

        UsersRepoTable.UserRepoRow userRow = new UsersRepoTable.UserRepoRow((VCSGisRepositoryLocaldbImpl) 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((VCSGisRepositoryLocaldbImpl) 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;

            }

        };

    }

}

package org.gvsig.vcsgis.lib.impl;

import java.io.File;

import java.util.List;

import static junit.framework.TestCase.assertEquals;

import org.apache.commons.io.FileUtils;

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.jdbc.JDBCStoreParameters;

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.SequentialCodeGenerator;

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_ENTITY_ALREADY_EXISTS;

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

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

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

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

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

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

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

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

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

@SuppressWarnings("UseSpecificCatch")

public abstract class AbstractTest07Checkout extends AbstractTestVCSGIS {

    public AbstractTest07Checkout(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

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

    // public void testHello() {}

    protected void testCheckout() throws Exception {

        try {

            utils().cleanRepositoryDatabase();

            VCSGisManager manager = VCSGisLocator.getVCSGisManager();

            manager.setCodeGenerator(new SequentialCodeGenerator());

            JDBCServerExplorer server = utils().openRepositoryServerExplorer("srv-checkout");

            File ws1file = utils().getFile(FileUtils.getFile("test-dbs", "ws-addcheckout1"));

            File ws2file = utils().getFile(FileUtils.getFile("test-dbs", "ws-addcheckout2"));

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

            assertEquals("vcsgisadmin.init status", ERR_NO_ERROR, r);

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

            utils().info_repository(repo);

            r = manager.initWorkspace(ws1file, repo, "Test checkout1", null);

            assertEquals("vcsgis.init_workspace1 status", ERR_NO_ERROR, r);

            VCSGisWorkspace ws1 = manager.openWorkspace(ws1file);

            assertNotNull("vcsgis.open_workspace1 status", ws1);

            utils().info_workspace(ws1);

            FeatureStore store1 = utils().openSourceStore1();

            ws1.add("sourceStore1", store1, "ID");

            assertEquals("ws1.add status", ERR_NO_ERROR, r);

            VCSGisWorkspaceEntity entity = ws1.getWorkspaceEntityByName("sourceStore1");

            assertEquals("State must be new", STATE_LOCAL_NEW, entity.getState());

            ws1.commit();

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

            entity = ws1.getWorkspaceEntityByName("sourceStore1");

            assertEquals("State must be new", STATE_LOCAL_UNMODIFIED, entity.getState());

            entities_setResources(server, "sourceStore1", "sourceStore1_res");

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

            assertEquals("vcsgis.init_workspace2 status", ERR_NO_ERROR, r);

            VCSGisWorkspace ws2 = manager.openWorkspace(ws2file);

            assertNotNull("vcsgis.open_workspace2 status", ws2);

            utils().info_workspace(ws2);

            r = ws2.checkout("sourceStore1");

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

            VCSGisWorkspaceEntity ent = ws2.getWorkspaceEntityByName("sourceStore1");

            assertEquals("ws2-checkout entity resources", "sourceStore1_res", ent.getResources());

            assertEquals("State must be new", STATE_LOCAL_UNMODIFIED, ent.getState());

            EntitiesTable.EntityRow entityRow = new EntitiesTable().getByEntityName(ws2, "sourceStore1");

            assertEquals("ws2-checkout entityState", STATE_LOCAL_UNMODIFIED, entityRow.getState());

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

            assertEquals("ws2-checkout changesTable", 0L, changesStore.size64());

            changesStore.dispose();

            FeatureStore store2 = ws2.getFeatureStore("sourceStore1");

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

            DisposeUtils.disposeQuietly(store2);

            DisposeUtils.disposeQuietly(store1);

            ws1.dispose();

            ws2.dispose();

            repo.dispose();

            server.dispose();

            manager.clean();

        } catch (Throwable th) {

            LOGGER.warn("", th);

            throw th;

        }

    }

    protected void testCheckout2() throws Exception {

        try {

            utils().cleanRepositoryDatabase();

            VCSGisManager manager = VCSGisLocator.getVCSGisManager();

            JDBCServerExplorer server = utils().openRepositoryServerExplorer("srv-checkout");

            File ws1file = utils().getFile(FileUtils.getFile("test-dbs", "ws-addcheckout1"));

            File ws2file = utils().getFile(FileUtils.getFile("test-dbs", "ws-addcheckout2"));

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

            assertEquals("vcsgisadmin.init status", ERR_NO_ERROR, r);

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

            utils().info_repository(repo);

            r = manager.initWorkspace(ws1file, repo, "Test checkout1", null);

            assertEquals("vcsgis.init_workspace1 status", ERR_NO_ERROR, r);

            VCSGisWorkspace ws1 = manager.openWorkspace(ws1file);

            assertNotNull("vcsgis.open_workspace1 status", ws1);

            utils().info_workspace(ws1);

            FeatureStore store1 = utils().openSourceStore1();

            r = ws1.add("sourceStore1", store1, "ID");

            assertEquals("ws1.add status", ERR_NO_ERROR, r);

            FeatureStore store2 = utils().openSourceStore2();

            r = ws1.add("sourceStore2", store2, "ID");

            assertEquals("ws1.add status", ERR_NO_ERROR, r);

            r = ws1.commit();

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

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

            assertEquals("vcsgis.init_workspace2 status", ERR_NO_ERROR, r);

            VCSGisWorkspace ws2 = manager.openWorkspace(ws2file);

            assertNotNull("vcsgis.open_workspace2 status", ws2);

            utils().info_workspace(ws2);

            List<VCSGisEntity> repoEntities = ws2.getRepositoryEntities();

            assertEquals("ws2-checkout repoEntities size", 2, repoEntities.size());

            List<VCSGisWorkspaceEntity> wsEntities = ws2.getWorkspaceEntities();

            assertEquals("ws2-checkout wsEntities size0", 0, wsEntities.size());

            r = ws2.checkout("sourceStore1");

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

            r = ws2.checkout("sourceStore1");

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

            wsEntities = ws2.getWorkspaceEntities();

            assertEquals("ws2-checkout wsEntities size1", 1, wsEntities.size());

            FeatureStore store3 = ws2.getFeatureStore("sourceStore1");

            assertEquals("ws2-checkout sizes", store1.size64(), store3.size64());

            DisposeUtils.disposeQuietly(store3);

            DisposeUtils.disposeQuietly(store2);

            DisposeUtils.disposeQuietly(store1);

            ws1.dispose();

            ws2.dispose();

            repo.dispose();

            server.dispose();

            manager.clean();

        } catch (Throwable th) {

            LOGGER.warn("", th);

            throw th;

        }

    }

    public static void entities_setResources(JDBCServerExplorer server, String tableName, String resource) throws Exception {

        JDBCStoreParameters entitiesOpenParameters = server.get(EntitiesRepoTable.TABLE_NAME);

        FeatureStore store = (FeatureStore) server.open(entitiesOpenParameters);

        store.edit();

        Feature f = store.findFirst("\"" + EntitiesRepoTable.ENTITY_NAME + "\" = '" + tableName + "'");

        EditableFeature ef = f.getEditable();

        ef.set(EntitiesRepoTable.RESOURCES, resource);

        store.update(ef);

        store.finishEditing();

        store.dispose();

    }

}

package org.gvsig.vcsgis.lib.impl;

import java.io.File;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import static junit.framework.TestCase.assertEquals;

import org.apache.commons.io.FileUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.TABLE_CONFIGURATION_NAME;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.TABLE_REPOSITORY_NAME;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.TABLE_RESOURCES_NAME;

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

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

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

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;

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

import org.gvsig.tools.util.MapBuilder;

import org.gvsig.vcsgis.lib.VCSGisLocator;

import org.gvsig.vcsgis.lib.VCSGisManager;

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

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

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

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

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

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

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

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

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

public abstract class AbstractTest02Initws extends AbstractTestVCSGIS {

    public AbstractTest02Initws(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

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

    // public void testHello() {}

    protected void testCreateWS() throws Exception {

        utils().cleanRepositoryDatabase();

        String testid = "initws";

        VCSGisManager vcsgismanager = VCSGisLocator.getVCSGisManager();

        JDBCServerExplorerParameters server = utils().getRepositoryServerExplorerParameters("srv-"+testid);

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

        int r = vcsgismanager.initRepository(server, null);

        assertEquals("initRepository status", 0, r);

        utils().info_repository(server);

        assertTrue("repository isRepository", vcsgismanager.isRepository(server));

        VCSGisRepository repo = vcsgismanager.openRepository(server);

        r = vcsgismanager.initWorkspace(wsfile, repo, "Test initws", null);

        assertEquals("initWorkspace ws status", 0, r);

        utils().info_workspace(wsfile);

        VCSGisWorkspace workspace = vcsgismanager.openWorkspace(wsfile);

        assertNotNull("Can't open workspace", workspace);

        assertTrue("workspace isWorkspace", vcsgismanager.isWorkspace(workspace.getExplorerParameters()));

        assertFalse("workspace isRepository", vcsgismanager.isRepository(workspace.getExplorerParameters()));

        JDBCServerExplorer wsexplorer = utils().openWorkspaceServerExplorer(wsfile);

        List<DataStoreParameters> tables = wsexplorer.list();

        Collections.sort(tables, new Comparator<DataStoreParameters>() {

            @Override

            public int compare(DataStoreParameters o1, DataStoreParameters o2) {

                return StringUtils.compare(

                        ((JDBCStoreParameters) o1).getTable(),

                        ((JDBCStoreParameters) o2).getTable()

                );

            }

        });

        Map<String, FeatureType> expectedTables = new MapBuilder<>()

                .add(WorkspaceChangesTable.TABLE_NAME,WorkspaceChangesTable.featureType())

                .add(VarsTable.TABLE_NAME,VarsTable.featureType())

                .add(EntitiesTable.TABLE_NAME,EntitiesTable.featureType())

                .add(RemoteChangesTable.TABLE_NAME,RemoteChangesTable.featureType())

                .add(LocalRevisionsTable.TABLE_NAME,LocalRevisionsTable.featureType())

                .add(UsersTable.TABLE_NAME,UsersTable.featureType())

                .add(TopologyplanTable.TABLE_NAME,TopologyplanTable.featureType())

                .add(TABLE_CONFIGURATION_NAME,null)

                .add(TABLE_REPOSITORY_NAME,null)

                .add(TABLE_RESOURCES_NAME,null)

                .build();

        Set<String>foundTableNames = new HashSet<>();

        for (DataStoreParameters table : tables) {

            JDBCStoreParameters params = (JDBCStoreParameters) table;

            String tableName = params.getTable();

            if (!tableName.startsWith("VCSGIS_") && !tableName.startsWith("GVSIGD_")) {

                continue;

            }

            assertTrue(expectedTables.containsKey(tableName));

            foundTableNames.add(tableName);

        }

        for (String tableName : expectedTables.keySet()) {

            assertTrue(foundTableNames.contains(tableName));

        }

        DataManager dataManager = DALLocator.getDataManager();

        for (DataStoreParameters tableParams : tables) {

            JDBCStoreParameters params = (JDBCStoreParameters) tableParams;

            String tableName = params.getTable();

            if (!tableName.startsWith("VCSGIS_") && !tableName.startsWith("GVSIGD_")) {

                continue;

            }

            FeatureStore store = (FeatureStore) dataManager.openStore(params.getProviderName(), params);

            FeatureType expectedFeatureType = expectedTables.get(tableName);

            if( expectedFeatureType!=null ) {

                FeatureType ft = store.getDefaultFeatureTypeQuietly();

                for (FeatureAttributeDescriptor expectedAttr : expectedFeatureType) {

                    FeatureAttributeDescriptor attr = ft.getAttributeDescriptor(expectedAttr.getName());

                    assertNotNull("Attr "+expectedAttr.getName(), attr);

                    assertEquals("Attr "+expectedAttr.getName()+" type", expectedAttr.getType(), attr.getType());

                    assertEquals("Attr "+expectedAttr.getName()+" size", expectedAttr.getSize(), attr.getSize());

                    assertEquals("Attr "+expectedAttr.getName()+" isPrimaryKey", expectedAttr.isPrimaryKey(), attr.isPrimaryKey());

                    assertEquals("Attr "+expectedAttr.getName()+" isIndexed", expectedAttr.isIndexed(), attr.isIndexed());

                    assertEquals("Attr "+expectedAttr.getName()+" allowIndexDuplicateds", expectedAttr.allowIndexDuplicateds(), attr.allowIndexDuplicateds());

                    assertEquals("Attr "+expectedAttr.getName()+" isReadOnly", expectedAttr.isReadOnly(), attr.isReadOnly());

                    assertEquals("Attr "+expectedAttr.getName()+" DefaultValue", expectedAttr.getDefaultValue(), attr.getDefaultValue());

                }

            }

            store.dispose();

        }

        repo.dispose();

        workspace.dispose();

        wsexplorer.dispose();

        vcsgismanager.clean();

    }

}

package org.gvsig.vcsgis.lib.impl;

import java.io.File;

import static junit.framework.TestCase.assertEquals;

import org.apache.commons.io.FileUtils;

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.vcsgis.lib.SequentialCodeGenerator;

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.OP_DELETE;

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

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

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

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

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

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

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

public abstract class AbstractTest18Revert extends AbstractTestVCSGIS {

    public AbstractTest18Revert(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

    }

    @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() {}

    protected void testRevert() throws Exception {

        utils().cleanRepositoryDatabase();

        JDBCServerExplorer server = utils().openRepositoryServerExplorer("srv-updatelocalmodified");

        File ws1file = utils().getFile(FileUtils.getFile("test-dbs","ws1-updatelocalmodified")); 

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        manager.setCodeGenerator(new SequentialCodeGenerator());

        int r;

        Feature f;

        EditableFeature ef;

        VCSGisWorkspaceEntity entity;

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

        // Inicializamos el repositorio y lo abrimos

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

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

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

        utils().info_repository(repo);

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

        // Creamos workspace1 y lo abrimos.

        r = manager.initWorkspace(ws1file, repo, "ws1: Test update local modified", null);

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

        VCSGisWorkspace ws1 = manager.openWorkspace(ws1file);

        utils().info_workspace(ws1);

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

        // Adicionamos al workspace1 la tabla "test" y la commitamos.

        utils().test_add(ws1);

        utils().test_commit(ws1);

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

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

        utils().test_modify( ws1,

                "update", 2, "BB2",

                "delete", 3, "CCC",

                "insert", 4, "DDD"

        );

        entity = ws1.getWorkspaceEntityByName("test");

        assertEquals("State must be local modified", STATE_LOCAL_MODIFIED, entity.getState());

        // Comprobamos que en el workspace1 hay lo que toca

        utils().test_checkall(ws1, 

                1, "AAA",

                2, "BB2",

                4, "DDD"

        );

        // Comprobamos los cambios locales

        utils().test_checklocalchanges(ws1, 

                OP_UPDATE, 2, "BB2",

                OP_DELETE, 3, "CCC",

                OP_INSERT, 4, "DDD"

        );

        ws1.revert("test", null);

        entity = ws1.getWorkspaceEntityByName("test");

        assertEquals("State must be unmodified", STATE_LOCAL_UNMODIFIED, entity.getState());

        // Comprobamos que en el workspace1 se han recuperado los valores previos

         utils().test_checkall(ws1, 

            1, "AAA",

            2, "BBB",

            3, "CCC"

        );

        // Comprobamos que se han eliminado los cambios locales

        utils().test_checklocalchanges(ws1); //No local changes

    }

    protected void testRevert2() throws Exception {

        utils().cleanRepositoryDatabase();

        JDBCServerExplorer server = utils().openRepositoryServerExplorer("srv-updatelocalmodified");

        File ws1file = utils().getFile(FileUtils.getFile("test-dbs","ws1-updatelocalmodified")); 

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        manager.setCodeGenerator(new SequentialCodeGenerator());

        int r;

        Feature f;

        EditableFeature ef;

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

        // Inicializamos el repositorio y lo abrimos

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

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

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

        utils().info_repository(repo);

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

        // Creamos workspace1 y lo abrimos.

        r = manager.initWorkspace(ws1file, repo, "ws1: Test update local modified", null);

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

        VCSGisWorkspace ws1 = manager.openWorkspace(ws1file);

        utils().info_workspace(ws1);

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

        // Adicionamos al workspace1 la tabla "test" y la commitamos.

        utils().test_add(ws1);

        utils().test_commit(ws1);

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

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

        utils().test_modify( ws1,

                "update", 2, "BB2",

                "delete", 3, "CCC",

                "insert", 4, "DDD"

        );

        // Comprobamos que en el workspace1 hay lo que toca

        utils().test_checkall(ws1, 

                1, "AAA",

                2, "BB2",

                4, "DDD"

        );

        // Comprobamos los cambios locales

        utils().test_checklocalchanges(ws1, 

                OP_UPDATE, 2, "BB2",

                OP_DELETE, 3, "CCC",

                OP_INSERT, 4, "DDD"

        );

        utils().test_modify( ws1,

                "update", 2, "BB3",

                "update", 4, "DD2"

        );

        // Comprobamos que en el workspace1 hay lo que toca

        utils().test_checkall(ws1, 

                1, "AAA",

                2, "BB3",

                4, "DD2"

        );

        // Comprobamos los cambios locales

        utils().test_checklocalchanges(ws1, 

                OP_UPDATE, 2, "BB3",

                OP_DELETE, 3, "CCC",

                OP_INSERT, 4, "DD2"

        );

        utils().test_modify( ws1,

                "update", 2, "BB4",

                "update", 4, "DD3"

        );

        // Comprobamos que en el workspace1 hay lo que toca

        utils().test_checkall(ws1, 

                1, "AAA",

                2, "BB4",

                4, "DD3"

        );

        // Comprobamos los cambios locales

        utils().test_checklocalchanges(ws1, 

                OP_UPDATE, 2, "BB4",

                OP_DELETE, 3, "CCC",

                OP_INSERT, 4, "DD3"

        );

        ws1.revert("test", null);

        // Comprobamos que en el workspace1 se han recuperado los valores previos

         utils().test_checkall(ws1, 

            1, "AAA",

            2, "BBB",

            3, "CCC"

        );

        // Comprobamos que se han eliminado los cambios locales

        utils().test_checklocalchanges(ws1); //No local changes

    }

}

package org.gvsig.vcsgis.lib.impl;

import java.io.File;

import java.util.List;

import static junit.framework.TestCase.assertEquals;

import org.apache.commons.io.FileUtils;

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.fmap.geom.Geometry;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.vcsgis.lib.SequentialCodeGenerator;

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.STATE_LOCAL_NEW;

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

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

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

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

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

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

@SuppressWarnings("UseSpecificCatch")

public abstract class AbstractTest17Geom1 extends AbstractTestVCSGIS {

    public AbstractTest17Geom1(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

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

    // public void testHello() {}

    protected void testGeom1() throws Exception {

        try {

            utils().cleanRepositoryDatabase();

            VCSGisManager manager = VCSGisLocator.getVCSGisManager();

            manager.setCodeGenerator(new SequentialCodeGenerator());

            JDBCServerExplorer server = utils().openRepositoryServerExplorer("srv-geom1");

            File ws1file = utils().getFile(FileUtils.getFile("test-dbs", "ws-geom1_1"));

            File ws2file = utils().getFile(FileUtils.getFile("test-dbs", "ws-geom1_2"));

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

            assertEquals("vcsgisadmin.init status", ERR_NO_ERROR, r);

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

            utils().info_repository(repo);

            r = manager.initWorkspace(ws1file, repo, "Test geom1 A", null);

            assertEquals("vcsgis.init_workspace1 status", ERR_NO_ERROR, r);

            VCSGisWorkspace ws1 = manager.openWorkspace(ws1file);

            assertNotNull("vcsgis.open_workspace1 status", ws1);

            utils().info_workspace(ws1);

            FeatureStore store1 = utils().openGeom1Store();

            ws1.add("Geom1Store", store1, "PRO_NAME");

            assertEquals("ws1.add status", ERR_NO_ERROR, r);

            VCSGisWorkspaceEntity entity = ws1.getWorkspaceEntityByName("Geom1Store");

            assertEquals("State must be new", STATE_LOCAL_NEW, entity.getState());

            ws1.commit();

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

            entity = ws1.getWorkspaceEntityByName("Geom1Store");

            assertEquals("State must be new", STATE_LOCAL_UNMODIFIED, entity.getState());

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

            assertEquals("vcsgis.init_workspace2 status", ERR_NO_ERROR, r);

            VCSGisWorkspace ws2 = manager.openWorkspace(ws2file);

            assertNotNull("vcsgis.open_workspace2 status", ws2);

            utils().info_workspace(ws2);

            r = ws2.checkout("Geom1Store");

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

            VCSGisWorkspaceEntity ent = ws2.getWorkspaceEntityByName("Geom1Store");

            assertEquals("State must be new", STATE_LOCAL_UNMODIFIED, ent.getState());

            EntitiesTable.EntityRow entityRow = new EntitiesTable().getByEntityName(ws2, "Geom1Store");

            assertEquals("ws2-geom1 entityState", STATE_LOCAL_UNMODIFIED, entityRow.getState());

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

            assertEquals("ws2-geom1 changesTable", 0L, changesStore.size64());

            FeatureStore store2 = ws2.getFeatureStore("Geom1Store");

            assertEquals("ws2-geom1 sizes", store1.size64(), store2.size64());

            List<Feature> features1 = store1.getFeatures();

            List<Feature> features2 = store2.getFeatures();

            for (int i = 0; i < features1.size(); i++) {

                Geometry g1 = features1.get(i).getDefaultGeometry();

                Geometry g2 = features2.get(i).getDefaultGeometry();

                assertEquals("ws2-geom1 check geometries "+i, g1.convertToHexWKB(), g2.convertToHexWKB());

            }

            DisposeUtils.disposeQuietly(store2);

            DisposeUtils.disposeQuietly(store1);

        } catch (Throwable th) {

            LOGGER.warn("", th);

            throw th;

        }

    }

}

package org.gvsig.vcsgis.lib.impl.h2spatial;

import org.gvsig.vcsgis.lib.impl.AbstractTest04AddEntity;

import org.gvsig.vcsgis.lib.impl.AbstractTestUtils;

public class Test04AddEntity extends AbstractTest04AddEntity {

    private TestUtilsH2Spatial utils;

    public Test04AddEntity(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp(); //To change body of generated methods, choose Tools | Templates.

        this.utils = new TestUtilsH2Spatial();

    }

    @Override

    protected AbstractTestUtils utils() {

        return this.utils;

    }

    @Override

    public void testAdd_entity1() throws Exception {

        super.testAdd_entity1(); 

    }

}

package org.gvsig.vcsgis.lib.impl.h2spatial;

import org.gvsig.vcsgis.lib.impl.AbstractTest08Update;

import org.gvsig.vcsgis.lib.impl.AbstractTestUtils;

public class Test08Update extends AbstractTest08Update {

    private TestUtilsH2Spatial utils;

    public Test08Update(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp(); //To change body of generated methods, choose Tools | Templates.

        this.utils = new TestUtilsH2Spatial();

    }

    @Override

    protected AbstractTestUtils utils() {

        return this.utils;

    }

    @Override

    public void testUpdate1() throws Exception {

        super.testUpdate1(); 

    }

    @Override

    public void testUpdate2() throws Exception {

        super.testUpdate2(); 

    }

}

package org.gvsig.vcsgis.lib.impl.h2spatial;

import org.gvsig.vcsgis.lib.impl.AbstractTest01InitRepo;

import org.gvsig.vcsgis.lib.impl.AbstractTestUtils;

public class Test01InitRepo extends AbstractTest01InitRepo {

    private TestUtilsH2Spatial utils;

    public Test01InitRepo(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp(); //To change body of generated methods, choose Tools | Templates.

        this.utils = new TestUtilsH2Spatial();

    }

    @Override

    protected AbstractTestUtils utils() {

        return this.utils;

    }

    @Override

    public void testInit1() throws Exception {

        super.testInit1();

    }

}

package org.gvsig.vcsgis.lib.impl.h2spatial;

import org.gvsig.vcsgis.lib.impl.AbstractTest12Commit;

import org.gvsig.vcsgis.lib.impl.AbstractTestUtils;

public class Test12Commit extends AbstractTest12Commit {

    private TestUtilsH2Spatial utils;

    public Test12Commit(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp(); //To change body of generated methods, choose Tools | Templates.

        this.utils = new TestUtilsH2Spatial();

    }

    @Override

    protected AbstractTestUtils utils() {

        return this.utils;

    }

    @Override

    public void testCommit() throws Exception {

        super.testCommit(); 

    }

    @Override

    public void testCommit700changes() throws Exception {

        super.testCommit700changes();

    }

}

package org.gvsig.vcsgis.lib.impl.h2spatial;

import org.gvsig.vcsgis.lib.impl.AbstractTest09CommitOutdated;

import org.gvsig.vcsgis.lib.impl.AbstractTestUtils;

public class Test09CommitOutdated extends AbstractTest09CommitOutdated {

    private TestUtilsH2Spatial utils;

    public Test09CommitOutdated(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp(); //To change body of generated methods, choose Tools | Templates.

        this.utils = new TestUtilsH2Spatial();

    }

    @Override

    protected AbstractTestUtils utils() {

        return this.utils;

    }

    @Override

    public void testCommitOutdated() throws Exception {

        super.testCommitOutdated(); 

    }

}

package org.gvsig.vcsgis.lib.impl.h2spatial;

import org.gvsig.vcsgis.lib.impl.AbstractTest05Add;

import org.gvsig.vcsgis.lib.impl.AbstractTestUtils;

public class Test05Add extends AbstractTest05Add {

    private TestUtilsH2Spatial utils;

    public Test05Add(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp(); //To change body of generated methods, choose Tools | Templates.

        this.utils = new TestUtilsH2Spatial();

    }

    @Override

    protected AbstractTestUtils utils() {

        return this.utils;

    }

    @Override

    public void testAdd() throws Exception {

        super.testAdd(); 

    }

}

package org.gvsig.vcsgis.lib.impl.h2spatial;

import org.gvsig.vcsgis.lib.impl.AbstractTest10UpdateLocalModified;

import org.gvsig.vcsgis.lib.impl.AbstractTestUtils;

public class Test10UpdateLocalModified extends AbstractTest10UpdateLocalModified {