gvSIG projects pool

#Wed Feb 08 09:09:55 CET 2023

buildNumber=100

package org.gvsig.vcsgis.app.server;

import java.io.File;

import java.io.OutputStreamWriter;

import java.net.URL;

import org.apache.commons.io.FileUtils;

import org.eclipse.jetty.server.Server;

import org.gvsig.fmap.dal.DataStore;

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

import static org.gvsig.vcsgis.app.server.VCSGisJettyServerUtils.SERVER_PORT;

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

import org.gvsig.vcsgis.lib.server.VCSGisServerUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class TestServerUtils  {

    public static final Logger LOGGER = LoggerFactory.getLogger(TestServerUtils.class);

    public static final String PROVIDER_NAME = DataStore.H2SPATIAL_PROVIDER_NAME;

    static Server createServer(AbstractTestUtils utils, JDBCServerExplorerParameters explorerParams) throws Exception {

        URL config_url = TestServerUtils.class.getResource("/server/vcsgisserver.config");

        OutputStreamWriter consoleWriter = new OutputStreamWriter(System.out);

        VCSGisServerUtils.setConsoleWriter(consoleWriter);        

        VCSGisServerUtils.setConfiguration(config_url);

        VCSGisServerUtils.setConnectionParameters(explorerParams);

        VCSGisServerUtils.writeConfiguration(config_url);

        File rootFolder = utils().getFile(new File("static"));

        Server server = VCSGisJettyServerUtils.createServer(SERVER_PORT, null, rootFolder.getAbsolutePath());

        return server;

    }

    private static class LocalTestUtilsH2Spatial extends org.gvsig.vcsgis.lib.impl.h2spatial.TestUtilsH2Spatial {

        // Esto fuerza a que el class loader de esta clase esta en este proyecto.

    }

    private static LocalTestUtilsH2Spatial utils = null;

    public static AbstractTestUtils utils() {

        if( utils==null ) {

            utils = new LocalTestUtilsH2Spatial();

        }

        return utils;

    }

}

package org.gvsig.vcsgis.app.server;

import java.io.File;

import java.net.URL;

import java.util.Locale;

import junit.framework.TestCase;

import static junit.framework.TestCase.assertEquals;

import org.apache.commons.io.FileUtils;

import org.eclipse.jetty.server.Server;

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

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

import org.gvsig.tools.dispose.DisposeUtils;

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

import static org.gvsig.vcsgis.app.server.TestServerUtils.createServer;

import static org.gvsig.vcsgis.app.server.TestServerUtils.utils;

import static org.gvsig.vcsgis.app.server.VCSGisJettyServerUtils.SERVER_PORT;

import org.gvsig.vcsgis.lib.VCSGisEntity;

import org.gvsig.vcsgis.lib.VCSGisLocator;

import org.gvsig.vcsgis.lib.VCSGisManager;

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

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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class TestSrv01AddCommit extends TestCase {

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

    static{

            Locale.setDefault(Locale.forLanguageTag("es-ES"));

    }

    public TestSrv01AddCommit(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

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

    // public void testHello() {}

    public void testAddCommit() throws Exception {

        final String testid = "ServerAddCommit";

        final URL serverUrl = new URL("http://localhost:" + SERVER_PORT + "/");

        VCSGisManager vcsgismanager = VCSGisLocator.getVCSGisManager();

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

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

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

        // Creamos el server y obtenemos el repositorio del server

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

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

        Server server = createServer(utils(),explorerParams);

        VCSGisWorkspaceEntity lentity = null;

        long expectedRows = -1;

        try {

            server.start();

            VCSGisRepository repositoryRemote = vcsgismanager.openRepository(serverUrl);

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

            // Creamos un workspace y preparamos los datos en el para hacer un commit

            r = vcsgismanager.initWorkspace(wsfile, repositoryRemote, "Test add and commit", null);

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

            VCSGisWorkspace ws = vcsgismanager.openWorkspace(wsfile);

            utils().info_workspace(ws);

            FeatureStore sourceStore = utils().openSourceStore1();

            expectedRows = sourceStore.getFeatureCount();

            r = ws.add("sourceStore1", sourceStore, "id");

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

            DisposeUtils.disposeQuietly(sourceStore);

            r = ws.commit();

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

            lentity = ws.getWorkspaceEntity("sourceStore1");

        } finally {

            server.stop();

        }

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

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

        // los mismos registros que la original.

        VCSGisRepositoryLocaldbImpl repositoryLocal = (VCSGisRepositoryLocaldbImpl) vcsgismanager.openRepository(explorerParams);

        VCSGisEntity rentity = repositoryLocal.getEntityByName("sourceStore1");

        assertEquals("Check revision codes 1", lentity.getLocalRevisionCode(), rentity.getRepositoryRevisionCode());

        assertEquals("Check revision codes 2", lentity.getRepositoryRevisionCode(), rentity.getRepositoryRevisionCode());

        FeatureStore dataStore = repositoryLocal.getFeatureStore(DataRepoTable.TABLE_NAME, true);

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

        DisposeUtils.disposeQuietly(dataStore);

        repositoryLocal.dispose();

    }

}

package org.gvsig.vcsgis.app.server;

import java.io.File;

import java.net.URL;

import java.util.List;

import java.util.Locale;

import junit.framework.TestCase;

import static junit.framework.TestCase.assertEquals;

import org.apache.commons.io.FileUtils;

import org.eclipse.jetty.server.Server;

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

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

import org.gvsig.tools.dispose.DisposeUtils;

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

import static org.gvsig.vcsgis.app.server.TestServerUtils.createServer;

import static org.gvsig.vcsgis.app.server.TestServerUtils.utils;

import static org.gvsig.vcsgis.app.server.VCSGisJettyServerUtils.SERVER_PORT;

import org.gvsig.vcsgis.lib.VCSGisEntity;

import org.gvsig.vcsgis.lib.VCSGisLocator;

import org.gvsig.vcsgis.lib.VCSGisManager;

import org.gvsig.vcsgis.lib.VCSGisUserIdentificationRequester;

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class TestSrv06Authenticate extends TestCase {

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

    static{

            Locale.setDefault(Locale.forLanguageTag("es-ES"));

    }

    public TestSrv06Authenticate(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

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

    // public void testHello() {}

    public void testAuthenticatedCommit() throws Exception {

        final String testid = "ServerAddCommit";

        final URL serverUrl = new URL("http://localhost:" + SERVER_PORT + "/");

        VCSGisManager vcsgismanager = VCSGisLocator.getVCSGisManager();

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

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

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

        // Creamos el server y obtenemos el repositorio del server

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

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

        VCSGisRepositoryLocaldbImpl repositoryLocal = (VCSGisRepositoryLocaldbImpl) vcsgismanager.openRepository(explorerParams);

        enableAuthentication(repositoryLocal);

        repositoryLocal.dispose();

        Server server = createServer(utils(),explorerParams);

        try {

            server.start();

            VCSGisRepository repositoryRemote = vcsgismanager.openRepository(serverUrl);

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

            // Creamos un workspace y preparamos los datos en el para hacer un commit

            r = vcsgismanager.initWorkspace(wsfile, repositoryRemote, "Test add and commit", null);

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

            VCSGisWorkspace ws = vcsgismanager.openWorkspace(wsfile);

            utils().info_workspace(ws);

            ws.setUserIdentificationRequester(new VCSGisUserIdentificationRequester() {

                int retries = 0;

                @Override

                public boolean requestIdentification() {

                    if (retries++ > 5) {

                        return false;

                    }

                    return true;

                }

                @Override

                public String getUserId() {

                    return "test";

                }

                @Override

                public String getPassword() {

                    return "password";

                }

            });

            FeatureStore sourceStore = utils().openSourceStore1();

            long expectedRows = sourceStore.getFeatureCount();

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

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

            DisposeUtils.disposeQuietly(sourceStore);

            r = ws.commit();

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

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

            // Comprobamos que en el server esta la tabla que acabamos de adicionar

            ws.updateEntitiesFromRepository(null);

            List<VCSGisEntity> rentities = ws.getRepositoryEntities();

            assertEquals("Num entities in server", 1, rentities.size());

            assertEquals("Name of the entity in server", "sourceStore1", rentities.get(0).getEntityName());

        } finally {

            server.stop();

        }

    }

    private void enableAuthentication(VCSGisRepositoryLocaldbImpl repo) {

        ConfigRepoTable varsTable = new ConfigRepoTable();

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

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

        userRow.setIdentifier("test");

        userRow.setPassword("password");

        userRow.insert();

    }

}

package org.gvsig.vcsgis.app.server;

import java.io.File;

import java.net.URL;

import java.util.List;

import java.util.Locale;

import junit.framework.TestCase;

import static junit.framework.TestCase.assertEquals;

import org.apache.commons.io.FileUtils;

import org.eclipse.jetty.server.Server;

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

import org.gvsig.tools.dispose.DisposeUtils;

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

import static org.gvsig.vcsgis.app.server.TestServerUtils.createServer;

import static org.gvsig.vcsgis.app.server.TestServerUtils.utils;

import static org.gvsig.vcsgis.app.server.VCSGisJettyServerUtils.SERVER_PORT;

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

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

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

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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class TestSrv14UpdateWithConflict extends TestCase {

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

    private Server server;

    static{

            Locale.setDefault(Locale.forLanguageTag("es-ES"));

    }

    public TestSrv14UpdateWithConflict(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    private VCSGisWorkspace[] initTest() throws Exception {

        final String testid = "ServerUpdateWithConflict";

        final URL serverUrl = new URL("http://localhost:" + SERVER_PORT + "/");

        VCSGisManager vcsgismanager = VCSGisLocator.getVCSGisManager();

//        JDBCServerExplorer server = TestUtils.openServerExplorer("srv-update");

        SequentialCodeGenerator.reset();

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

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

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

        // Creamos el server y obtenemos el repositorio del server

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

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

        VCSGisRepositoryLocaldbImpl repositoryLocal = (VCSGisRepositoryLocaldbImpl) vcsgismanager.openRepository(explorerParams);

        repositoryLocal.setAllowAssignTheRevisionDate(true);

        utils().info_repository(repositoryLocal);

        repositoryLocal.dispose();

        server = createServer(utils(), explorerParams);

        server.start();

        VCSGisRepository repo = vcsgismanager.openRepository(serverUrl);

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

        File ws2file = utils().getFile(FileUtils.getFile("test-dbs", "ws2-update"));

        File ws3file = utils().getFile(FileUtils.getFile("test-dbs", "ws3-update"));

        vcsgismanager.setCodeGenerator(new SequentialCodeGenerator());

        List<Feature> features;

        FeatureStore store2;

        FeatureStore store3;

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

        // Creamos workspace1 y lo abrimos.

        r = vcsgismanager.initWorkspace(ws1file, repo, "Test update1", null);

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

        VCSGisWorkspace ws1 = vcsgismanager.openWorkspace(ws1file);

        utils().info_workspace(ws1);

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

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

        //REV 0

        FeatureStore sourceTest = utils().openSourceStore2();

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

        DisposeUtils.disposeQuietly(sourceTest);

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

        r = ws1.commit();

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

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

        // Inicializamos el workspace2 asociandolo al mismo repositorio que 

        // workspace1 y lo abrimos.

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

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

        VCSGisWorkspace ws2 = vcsgismanager.openWorkspace(ws2file);

        utils().info_workspace(ws2);

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

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

        // y comprobamos que tiene lo que toca.

        r = ws2.checkout("test");

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

        store2 = ws2.openFeatureStore("test",false);

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

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

        utils().test_check(features, 0, 1, "AAA");

        utils().test_check(features, 1, 2, "BBB");

        utils().test_check(features, 2, 3, "CCC");

        DisposeUtils.disposeQuietly(features);

        DisposeUtils.disposeQuietly(store2);

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

        // Inicializamos el workspace3 asociandolo al mismo repositorio que 

        // workspace1 y lo abrimos.

        r = vcsgismanager.initWorkspace(ws3file, repo, "Test update2", null);

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

        VCSGisWorkspace ws3 = vcsgismanager.openWorkspace(ws3file);

        utils().info_workspace(ws3);

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

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

        // y comprobamos que tiene lo que toca.

        r = ws3.checkout("test");

        assertEquals("ws3.update-1 status", ERR_NO_ERROR, r);

        store3 = ws3.openFeatureStore("test",false);

        assertEquals("ws3-upfate sizes", 3, store3.size64());

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

        utils().test_check(features, 0, 1, "AAA");

        utils().test_check(features, 1, 2, "BBB");

        utils().test_check(features, 2, 3, "CCC");

        DisposeUtils.disposeQuietly(features);

        DisposeUtils.disposeQuietly(store2);

        DisposeUtils.disposeQuietly(store3);

        return new VCSGisWorkspace[]{ws1, ws2, ws3};

    }

    public void testTwoUpdatesAndMerge() throws Exception {

        try {

            VCSGisWorkspace[] wss = initTest();

            VCSGisWorkspace ws1 = wss[0];

            VCSGisWorkspace ws2 = wss[1];

            int r;

            Feature f;

            EditableFeature ef;

            FeatureStore store1;

            FeatureStore store2;

            // Añadimos al workspace1 una feature con una id concreta y la commitamos

            store1 = ws1.openFeatureStore("test",false);

            store1.edit();

            utils().test_update(store1, 3, "CC1");

            store1.finishEditing();

            DisposeUtils.disposeQuietly(store1);

            r = ws1.commit();

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

            // Añadimos al workspace2 una feature con la misma id

            store2 = ws2.openFeatureStore("test",false);

            store2.edit();

            utils().test_update(store2, 3, "CC2");

            store2.finishEditing();

            DisposeUtils.disposeQuietly(store2);

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

            // Preparamos la actualización de (updatePrepare) la tabla "test" en el workspace2 

            // comprobamos que funciona y que tiene lo que toca.

            r = ws2.updatePrepare("test");

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

//        assertTrue(false);

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

            // comprobamos que falla

            r = ws2.update("test");

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

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

            // comprobamos que no falla

            r = ws2.merge("test");

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

            //Comprobar que en la tabla de cambios locales hay 1 elemento

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

            assertEquals("ws2-changes size", 1, changes.size64());

            DisposeUtils.disposeQuietly(changes);

        } finally {

            server.stop();

        }

    }

    public void testTwoUpdatesMergeAndUpdate() throws Exception {

        try {

            VCSGisWorkspace[] wss = initTest();

            VCSGisWorkspace ws1 = wss[0];

            VCSGisWorkspace ws2 = wss[1];

            VCSGisWorkspace ws3 = wss[2];

            int r;

            Feature f;

            EditableFeature ef;

            FeatureStore store1;

            FeatureStore store2;

            FeatureStore store3;

            // Editamos en el workspace1 una feature con una id concreta y la commitamos

            store1 = ws1.openFeatureStore("test",false);

            store1.edit();

            utils().test_update(store1, 3, "CC1");

            store1.finishEditing();

            DisposeUtils.disposeQuietly(store1);

            r = ws1.commit();

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

            // Editamos en el workspace2 la feature con la misma id

            store2 = ws2.openFeatureStore("test",false);

            store2.edit();

            utils().test_update(store2, 3, "CC2");

            store2.finishEditing();

            DisposeUtils.disposeQuietly(store2);

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

            // Preparamos la actualización de (updatePrepare) la tabla "test" en el workspace2 

            // comprobamos que funciona y que tiene lo que toca.

            r = ws2.updatePrepare("test");

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

//        assertTrue(false);

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

            // comprobamos que falla

            r = ws2.update("test");

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

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

            // comprobamos que no falla

            r = ws2.merge("test");

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

            //Comprobar que en la tabla de cambios locales hay 1 elemento

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

            assertEquals("ws2-changes size", 1, changes.size64());

            DisposeUtils.disposeQuietly(changes);

            // Commitamos el workspace2

            r = ws2.commit();

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

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

            // Preparamos la actualización de (updatePrepare) la tabla "test" en el workspace3

            // comprobamos que funciona y que tiene lo que toca.

            r = ws3.updatePrepare("test");

            assertEquals("ws3.update-1 status", ERR_NO_ERROR, r);

            //Comprobar que en la tabla de cambios remotos hay 1 elemento

            FeatureStore remoteChanges = ws3.getFeatureStore(RemoteChangesTable.TABLE_NAME);

            assertEquals("ws3-remoteChanges size", 1, remoteChanges.size64());

            DisposeUtils.disposeQuietly(remoteChanges);

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

            // comprobamos que no falla

            r = ws3.update("test");

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

            store3 = ws3.openFeatureStore("test",false);

            assertEquals("ws3-update sizes", 3, store3.size64());

            List<Feature> features = store3.getFeatures((Expression) null, "id", true);

            utils().test_check(features, 0, 1, "AAA");

            utils().test_check(features, 1, 2, "BBB");

            utils().test_check(features, 2, 3, "CC2");

            DisposeUtils.disposeQuietly(store3);

        } finally {

            server.stop();

        }

    }

    public void testTwoUpdatesAndUpdate() throws Exception {

        try {

            VCSGisWorkspace[] wss = initTest();

            VCSGisWorkspace ws1 = wss[0];

            VCSGisWorkspace ws2 = wss[1];

            int r;

            Feature f;

            EditableFeature ef;

            FeatureStore store1;

            FeatureStore store2;

            // Añadimos al workspace1 una feature con una id concreta y la commitamos

            store1 = ws1.openFeatureStore("test",false);

            store1.edit();

            utils().test_update(store1, 3, "CC1");

            store1.finishEditing();

            DisposeUtils.disposeQuietly(store1);

            r = ws1.commit();

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

            // Añadimos al workspace2 una feature con la misma id

            store2 = ws2.openFeatureStore("test",false);

            store2.edit();

            utils().test_update(store2, 3, "CC2");

            store2.finishEditing();

            DisposeUtils.disposeQuietly(store2);

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

            // Preparamos la actualización de (updatePrepare) la tabla "test" en el workspace2 

            // comprobamos que funciona y que tiene lo que toca.

            r = ws2.updatePrepare("test");

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

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

            // comprobamos que falla

            r = ws2.update("test");

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

            //Seleccionar el cambio conflictivo id=4

            utils().test_selectRemoteChange(ws2, true, 3, "CC1", ws1);

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

            // comprobamos que no falla

            r = ws2.update("test");

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

            //Comprobar que en la tabla de cambios locales no hay nada

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

            assertEquals("ws2-changes size", 0, changes.size64());

            DisposeUtils.disposeQuietly(changes);

        } finally {

            server.stop();

        }

    }

    public void testTwoInsertsAndUpdate() throws Exception {

        try {

            VCSGisWorkspace[] wss = initTest();

            VCSGisWorkspace ws1 = wss[0];

            VCSGisWorkspace ws2 = wss[1];

            int r;

            Feature f;

            EditableFeature ef;

            List<Feature> features;

            FeatureStore store1;

            FeatureStore store2;

            // Añadimos al workspace1 una feature con una id concreta y la commitamos

            store1 = ws1.openFeatureStore("test",false);

            store1.edit();

            utils().test_insert(store1, 4, "DD1");

            store1.finishEditing();

            DisposeUtils.disposeQuietly(store1);

            r = ws1.commit();

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

            // Añadimos al workspace2 una feature con la misma id

            store2 = ws2.openFeatureStore("test",false);

            store2.edit();

            utils().test_insert(store2, 4, "DD2");

            store2.finishEditing();

            DisposeUtils.disposeQuietly(store2);

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

            // Preparamos la actualización de (updatePrepare) la tabla "test" en el workspace2 

            // comprobamos que funciona y que tiene lo que toca.

            r = ws2.updatePrepare("test");

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

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

            // See in console debug message with 

            // "===: UPDATE_PREPARE: conflicts.  {     "id":4,     ..." 

            // and use here the value of the field VCSGISCODE

            utils().test_checkLocalChange(store2, changes, "00000000000036abcdef0123456789", OP_INSERT, 4, "DD2", STATE_CONFLICT);

            DisposeUtils.disposeQuietly(changes);

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

            // comprobamos que no falla

            r = ws2.update("test");

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

            //Seleccionar el cambio conflictivo id=4

            utils().test_selectRemoteChange(ws2, true, 4, "DD1", ws1);

            //update y comprobar que funciona y se ha borrado la feature conflictiva nuestra

            r = ws2.update("test");

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

            store2 = ws2.openFeatureStore("test",false);

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

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

            utils().test_check(features, 0, 1, "AAA");

            utils().test_check(features, 1, 2, "BBB");

            utils().test_check(features, 2, 3, "CCC");

            utils().test_check(features, 3, 4, "DD1");

            //Comprobar que en la tabla de cambios locales no hay nada

            changes = ws2.getFeatureStore(WorkspaceChangesTable.TABLE_NAME);

            assertEquals("ws2-changes size", 0, changes.size64());

            DisposeUtils.disposeQuietly(changes);

        } finally {

            server.stop();

        }

    }

    public void testTwoInsertsAndMerge() throws Exception {

        try {

            VCSGisWorkspace[] wss = initTest();

            VCSGisWorkspace ws1 = wss[0];

            VCSGisWorkspace ws2 = wss[1];

            int r;

            Feature f;

            EditableFeature ef;

            List<Feature> features;

            FeatureStore store1;

            FeatureStore store2;

            //Insertamos dos registros nuevos y repetirlo todo sin seleccionar cambio conflictivo y hacer un merge y que funcione

            // Añadimos al workspace1 una feature con una id concreta y la commitamos

            store1 = ws1.openFeatureStore("test",false);

            store1.edit();

            utils().test_insert(store1, 4, "DD1");

            store1.finishEditing();

            DisposeUtils.disposeQuietly(store1);

            r = ws1.commit();

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

            // Añadimos al workspace2 una feature con la misma id

            store2 = ws2.openFeatureStore("test",false);

            store2.edit();

            utils().test_insert(store2, 4, "DD2");

            store2.finishEditing();

            DisposeUtils.disposeQuietly(store2);

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

            // Preparamos la actualización de (updatePrepare) la tabla "test" en el workspace2 

            // comprobamos que funciona y que tiene lo que toca.

            r = ws2.updatePrepare("test");

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

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

            // comprobamos que falla

            r = ws2.update("test");

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

            //merge y comprobar que funciona y no se insertado el cambio conflictivo

            r = ws2.merge("test");

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

            store2 = ws2.openFeatureStore("test",false);

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

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

            utils().test_check(features, 0, 1, "AAA");

            utils().test_check(features, 1, 2, "BBB");

            utils().test_check(features, 2, 3, "CCC");

            utils().test_check(features, 3, 4, "DD2");

            //Comprobamos que se ha añadido a la tabla de cambios local el delete del cambio conflictivo

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

            assertEquals("ws2-changes size", 2, changes.size64());

            // See in console debug message with 

            // "===: UPDATE: add delete operation to RelatedFeatureCode ..." 

            // and use here the value RelatedFeatureCode

            utils().test_checkLocalChange(store2, changes, "00000000000028abcdef0123456789", OP_DELETE, 4, "DD1", -1);

            // See in console debug message with 

            // "===: UPDATE_PREPARE: conflicts.  {     "id":4,     "text":"DD2"" 

            // and use here the value of the field VCSGISCODE

            utils().test_checkLocalChange(store2, changes, "00000000000036abcdef0123456789", OP_INSERT, 4, "DD2", -1);

            DisposeUtils.disposeQuietly(changes);

        } finally {

            server.stop();

        }

    }

    public void testOneCommitAndUpdateOverDeleted() throws Exception {

        try {

            VCSGisWorkspace[] wss = initTest();

            VCSGisWorkspace ws1 = wss[0];

            VCSGisWorkspace ws2 = wss[1];

            List<Feature> features;

            int r;

            Feature f;

            EditableFeature ef;

            FeatureStore store1;

            FeatureStore store2;

            // Modificamos en workspace1 una feature con una id concreta y la commitamos

            store1 = ws1.openFeatureStore("test",false);

            store1.edit();

            utils().test_update(store1, 3, "CC1");

            store1.finishEditing();

            DisposeUtils.disposeQuietly(store1);

            r = ws1.commit();

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

            // Borramos en el workspace2 la feature con la misma id

            store2 = ws2.openFeatureStore("test",false);

            store2.edit();

            utils().test_delete(store2, 3, "CCC");

            store2.finishEditing();

            DisposeUtils.disposeQuietly(store2);

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

            // Preparamos la actualización de (updatePrepare) la tabla "test" en el workspace2 

            // comprobamos que funciona y que tiene lo que toca.

            r = ws2.updatePrepare("test");

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

//        assertTrue(false);

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

            // comprobamos que falla

            r = ws2.update("test");

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

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

//        // comprobamos que no falla

//        r = ws2.merge("test");

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

            //Seleccionar el cambio conflictivo id=4

            utils().test_selectRemoteChange(ws2, true, 3, "CC1", ws1);

            //update y comprobar que funciona y no se ha insertado la feature conflictiva

            r = ws2.update("test");

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

            store2 = ws2.openFeatureStore("test",false);

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

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

            utils().test_check(features, 0, 1, "AAA");

            utils().test_check(features, 1, 2, "BBB");

            utils().test_check(features, 2, 3, "CC1");

            //Comprobar que en la tabla de cambios locales no hay nada

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

            assertEquals("ws2-changes size", 0, changes.size64());

            DisposeUtils.disposeQuietly(changes);

        } finally {

            server.stop();

        }

    }

    public void testOneCommitAndMergeOverDeleted() throws Exception {

        try {

            VCSGisWorkspace[] wss = initTest();

            VCSGisWorkspace ws1 = wss[0];

            VCSGisWorkspace ws2 = wss[1];

            List<Feature> features;

            int r;

            Feature f;

            EditableFeature ef;

            FeatureStore store1;

            FeatureStore store2;

            // Modificamos en workspace1 una feature con una id concreta y la commitamos

            store1 = ws1.openFeatureStore("test",false);

            store1.edit();

            utils().test_update(store1, 3, "CC1");

            store1.finishEditing();

            DisposeUtils.disposeQuietly(store1);

            r = ws1.commit();

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

            // Borramos en el workspace2 la feature con la misma id

            store2 = ws2.openFeatureStore("test",false);

            store2.edit();

            utils().test_delete(store2, 3, "CCC");

            store2.finishEditing();

            DisposeUtils.disposeQuietly(store2);

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

            // Preparamos la actualización de (updatePrepare) la tabla "test" en el workspace2 

            // comprobamos que funciona y que tiene lo que toca.

            r = ws2.updatePrepare("test");

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

//        assertTrue(false);

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

            // comprobamos que falla

//        r = ws2.update("test");

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

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

            // comprobamos que no falla

            r = ws2.merge("test");

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

            //Comprobamos que en workspace2 hay lo que toca

            store2 = ws2.openFeatureStore("test",false);

            assertEquals("ws2-update sizes", 2, store2.size64());

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

            utils().test_check(features, 0, 1, "AAA");

            utils().test_check(features, 1, 2, "BBB");

//        check(features, 2, 3, "CC1");

            //Comprobar que en la tabla de cambios locales permanece el cambio

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

            assertEquals("ws2-changes size", 1, changes.size64());

            DisposeUtils.disposeQuietly(changes);

        } finally {

            server.stop();

        }

    }

}

package org.gvsig.vcsgis.app.server;

import java.io.File;

import java.net.URL;

import java.util.List;

import java.util.Locale;

import junit.framework.TestCase;

import static junit.framework.TestCase.assertEquals;

import org.apache.commons.io.FileUtils;

import org.eclipse.jetty.server.Server;

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

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

import org.gvsig.tools.dispose.DisposeUtils;

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

import static org.gvsig.vcsgis.app.server.TestServerUtils.createServer;

import static org.gvsig.vcsgis.app.server.TestServerUtils.utils;

import static org.gvsig.vcsgis.app.server.VCSGisJettyServerUtils.SERVER_PORT;

import org.gvsig.vcsgis.lib.VCSGisEntity;

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.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class TestSrv02Entities extends TestCase {

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

    static{

            Locale.setDefault(Locale.forLanguageTag("es-ES"));

    }

    public TestSrv02Entities(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

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

    // public void testHello() {}

    public void testEntities() throws Exception {

        final String testid = "ServerAddCommit";

        final URL serverUrl = new URL("http://localhost:" + SERVER_PORT + "/");

        VCSGisManager vcsgismanager = VCSGisLocator.getVCSGisManager();

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

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

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

        // Creamos el server y obtenemos el repositorio del server

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

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

        Server server = createServer(utils(),explorerParams);

        try {

            server.start();

            VCSGisRepository repositoryRemote = vcsgismanager.openRepository(serverUrl);

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

            // Creamos un workspace y preparamos los datos en el para hacer un commit

            r = vcsgismanager.initWorkspace(wsfile, repositoryRemote, "Test add and commit", null);

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

            VCSGisWorkspace ws = vcsgismanager.openWorkspace(wsfile);

            utils().info_workspace(ws);

            FeatureStore sourceStore = utils().openSourceStore1();

            long expectedRows = sourceStore.getFeatureCount();

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

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

            DisposeUtils.disposeQuietly(sourceStore);

            r = ws.commit();

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

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

            // Comprobamos que en el server esta la tabla que acabamos de adicionar

            ws.updateEntitiesFromRepository(null);

            List<VCSGisEntity> rentities = ws.getRepositoryEntities();

            assertEquals("Num entities in server", 1, rentities.size());

            assertEquals("Name of the entity in server", "sourceStore1", rentities.get(0).getEntityName());

        } finally {

            server.stop();

        }

    }

}

package org.gvsig.vcsgis.app.server;

import java.io.File;

import java.net.URL;

import java.sql.Timestamp;

import java.util.List;

import java.util.Locale;

import junit.framework.TestCase;

import static junit.framework.TestCase.assertEquals;

import static junit.framework.TestCase.assertNotNull;

import org.apache.commons.io.FileUtils;

import org.eclipse.jetty.server.Server;

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

import org.gvsig.tools.dispose.DisposeUtils;

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

import static org.gvsig.vcsgis.app.server.TestServerUtils.createServer;

import static org.gvsig.vcsgis.app.server.TestServerUtils.utils;

import static org.gvsig.vcsgis.app.server.VCSGisJettyServerUtils.SERVER_PORT;

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

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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class TestSrv05Update extends TestCase {

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

    static{

            Locale.setDefault(Locale.forLanguageTag("es-ES"));

    }

    public TestSrv05Update(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    @SuppressWarnings("UnusedAssignment")

    public void testUpdate() throws Exception {

        final String testid = "ServerUpdate";

        final URL serverUrl = new URL("http://localhost:" + SERVER_PORT + "/");

        SequentialCodeGenerator.reset();

        VCSGisManager vcsgismanager = VCSGisLocator.getVCSGisManager();

        vcsgismanager.setCodeGenerator(new SequentialCodeGenerator());

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

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

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

        int r;

        Feature f;

        EditableFeature ef;

        List<Feature> features;

        FeatureStore store1;

        FeatureStore store2;

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

        // Creamos el server y obtenemos el repositorio del server

        r = vcsgismanager.initRepository(explorerParams, null);

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

        Server server = createServer(utils(),explorerParams);

        VCSGisWorkspaceEntity lentity = null;

        try {

            server.start();

            VCSGisRepository repositoryRemote = vcsgismanager.openRepository(serverUrl);

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

            // Creamos workspace1 y lo abrimos.

            r = vcsgismanager.initWorkspace(ws1file, repositoryRemote, "Test update1", null);

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

            VCSGisWorkspace ws1 = vcsgismanager.openWorkspace(ws1file);

            utils().info_workspace(ws1);

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

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

            FeatureStore sourceTest = utils().openSourceStore2();

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

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

            store1 = ws1.openFeatureStore("test",false);

            store1.edit();

            utils().test_insert(store1, 4, "DDD");

            utils().test_insert(store1, 5, "EEE");

            utils().test_insert(store1, 6, "FFF");

            store1.finishEditing();

            r = ws1.commit();

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

            DisposeUtils.disposeQuietly(sourceTest);

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

            // Inicializamos el workspace2 asociandolo al mismo repositorio que 

            // workspace1 y lo abrimos.

            r = vcsgismanager.initWorkspace(ws2file, repositoryRemote, "Test update2", null);

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

            VCSGisWorkspace ws2 = vcsgismanager.openWorkspace(ws2file);

            utils().info_workspace(ws2);

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

            // 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",false);

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

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

            utils().test_check(features, 0, 1, "AAA");

            utils().test_check(features, 1, 2, "BBB");

            utils().test_check(features, 2, 3, "CCC");

            utils().test_check(features, 3, 4, "DDD");

            utils().test_check(features, 4, 5, "EEE");

            utils().test_check(features, 5, 6, "FFF");

            DisposeUtils.disposeQuietly(features);

            DisposeUtils.disposeQuietly(store2);

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

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

            store1 = ws1.openFeatureStore("test",false);

            store1.edit();

            utils().test_insert(store1, 7, "GGG");

            utils().test_update(store1, 2, "BB2");

            utils().test_delete(store1, 3, "CCC");

            store1.finishEditing();

            DisposeUtils.disposeQuietly(store1);

            r = ws1.commit(Timestamp.valueOf("2020-02-17 10:11:12.123"), "Insertado DDD y modificado BBB a BB2", null);

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

            String localRevisionCode = ws2.getWorkspaceEntity("test").getRepositoryRevisionCode();

            assertEquals("ws2 localRevisionCode", "00000000000021abcdef0123456789", localRevisionCode);

            r = ws2.updatePrepare("test");

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

            r = ws2.update("test");

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

            store2 = ws2.openFeatureStore("test",false);

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

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

            utils().test_check(features, 0, 1, "AAA");

            utils().test_check(features, 1, 2, "BB2");

            utils().test_check(features, 2, 4, "DDD");

            utils().test_check(features, 3, 5, "EEE");

            utils().test_check(features, 4, 6, "FFF");

            utils().test_check(features, 5, 7, "GGG");

            DisposeUtils.disposeQuietly(features);

            DisposeUtils.disposeQuietly(store2);

            lentity = ws2.getWorkspaceEntity("test");

            ws1.dispose();

            ws2.dispose();

            ws1 = null;

            ws2 = null;

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

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

            // los mismos registros que la original.

        } finally {

            server.stop();

        }

        VCSGisRepositoryLocaldbImpl repositoryLocal = (VCSGisRepositoryLocaldbImpl) vcsgismanager.openRepository(explorerParams);

        VCSGisEntity rentity = repositoryLocal.getEntityByName("test");

        assertEquals("Check local revision code", lentity.getLocalRevisionCode(), rentity.getRepositoryRevisionCode());

        assertEquals("Check repository revision code", lentity.getRepositoryRevisionCode(), rentity.getRepositoryRevisionCode());

        repositoryLocal.dispose();

    }

}

package org.gvsig.vcsgis.app.server;

import java.io.File;

import java.net.URL;

import java.sql.Timestamp;

import java.util.Locale;

import junit.framework.TestCase;

import static junit.framework.TestCase.assertEquals;

import org.apache.commons.io.FileUtils;

import org.eclipse.jetty.server.Server;

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

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 static org.gvsig.vcsgis.app.server.TestServerUtils.createServer;

import static org.gvsig.vcsgis.app.server.TestServerUtils.utils;

import static org.gvsig.vcsgis.app.server.VCSGisJettyServerUtils.SERVER_PORT;

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

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

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

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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class TestSrv03Checkout extends TestCase {

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

    static{

            Locale.setDefault(Locale.forLanguageTag("es-ES"));

    }

    public TestSrv03Checkout(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

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

    // public void testHello() {}

    public void testCheckout() throws Exception {

        final String testid = "ServerCheckout";

        final URL serverUrl = new URL("http://localhost:" + SERVER_PORT + "/");

        VCSGisManager vcsgismanager = VCSGisLocator.getVCSGisManager();

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

        JDBCServerExplorerParameters explorerParams = serverdb.getParameters();

//        JDBCServerExplorerParameters explorerParams = TestUtils.getServerExplorerParameters("srv-"+testid);

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

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

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

        // Creamos el server y obtenemos el repositorio del server

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

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

        Server server = createServer(utils(),explorerParams);

        VCSGisWorkspaceEntity lentity = null;

        long expectedRows = -1;

        try {

            server.start();

            VCSGisRepository repositoryRemote = vcsgismanager.openRepository(serverUrl);

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

            // Creamos un workspace y preparamos los datos en el para hacer un commit

            r = vcsgismanager.initWorkspace(ws1file, repositoryRemote, "Test checkout ws1", null);

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

            VCSGisWorkspace ws1 = vcsgismanager.openWorkspace(ws1file);

            utils().info_workspace(ws1);

            FeatureStore sourceStore = utils().openSourceStore2();

            expectedRows = sourceStore.getFeatureCount();

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

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

            r = ws1.commit(Timestamp.valueOf("2020-02-17 10:11:12.123"), testid, null);

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

            entities_setResources(serverdb, "test", "test_res");

            DisposeUtils.disposeQuietly(sourceStore);

            r = vcsgismanager.initWorkspace(ws2file, repositoryRemote, "Test checkout ws2", null);

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

            VCSGisWorkspace ws2 = vcsgismanager.openWorkspace(ws2file);

            utils().info_workspace(ws2);

            r = ws2.checkout("test");

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

            lentity = ws2.getWorkspaceEntity("test");

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

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

            // los mismos registros que la original.

        } finally {

            server.stop();

        }

        VCSGisRepositoryLocaldbImpl repositoryLocal = (VCSGisRepositoryLocaldbImpl) vcsgismanager.openRepository(explorerParams);

        VCSGisEntity rentity = repositoryLocal.getEntityByName("test");

        assertEquals("Check revision codes 1", lentity.getLocalRevisionCode(), rentity.getRepositoryRevisionCode());

        assertEquals("Check revision codes 2", lentity.getRepositoryRevisionCode(), rentity.getRepositoryRevisionCode());

        assertEquals("Check resources", "test_res", lentity.getResources());

        FeatureStore dataStore = repositoryLocal.getFeatureStore(DataRepoTable.TABLE_NAME, true);

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

        DisposeUtils.disposeQuietly(dataStore);

        repositoryLocal.dispose();

    }

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

    }

}

package org.gvsig.vcsgis.app.server;

import java.io.File;

import java.net.URL;

import java.util.Locale;

import junit.framework.TestCase;

import org.apache.commons.io.FileUtils;

import org.eclipse.jetty.server.Server;

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

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

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