gvSIG projects pool

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <parent>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.vcsgis.app</artifactId>

        <version>1.0.36</version>

    </parent>

    <artifactId>org.gvsig.vcsgis.app.server</artifactId>

    <packaging>jar</packaging>

    <name>${project.artifactId}</name>

    <properties>

        <!-- Package info property values -->

        <gvsig.package.info.state>testing</gvsig.package.info.state>

        <gvsig.package.info.official>true</gvsig.package.info.official>

        <gvsig.package.info.name>vcsgis-server</gvsig.package.info.name>

        <gvsig.package.info.description>Provides a implementation of a HTTP server of VCSGis protocol (Version Control System for GIS).</gvsig.package.info.description>

        <gvsig.package.info.categories />

        <gvsig.package.info.javaVM>j1_8</gvsig.package.info.javaVM>

        <gvsig.package.info.poolURL>https://devel.gvsig.org/download/projects/gvsig-vcsgis/pool</gvsig.package.info.poolURL>

    </properties>

    <dependencies>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.andami</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.vcsgis.swing.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.vcsgis.swing.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.vcsgis.lib.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.app.mainplugin</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.app.document.table.app.mainplugin</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.vcsgis.tomcat.webapp</artifactId>

            <scope>runtime</scope>

            <type>war</type>

        </dependency>

        <dependency>

            <groupId>org.eclipse.jetty</groupId>

            <artifactId>jetty-server</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.eclipse.jetty</groupId>

            <artifactId>jetty-servlet</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.eclipse.jetty</groupId>

            <artifactId>jetty-webapp</artifactId>

            <scope>compile</scope>

            <exclusions>

                <exclusion>

                    <groupId>javax.servlet</groupId>

                    <artifactId>servlet-api</artifactId>

                </exclusion>

            </exclusions>

        </dependency>

        <dependency>

            <groupId>org.eclipse.jetty</groupId>

            <artifactId>jetty-util</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.eclipse.jetty</groupId>

            <artifactId>jetty-io</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.eclipse.jetty</groupId>

            <artifactId>jetty-jndi</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.vcsgis.lib.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>${org.gvsig.h2spatial.provider}</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>${org.gvsig.fmap.geometry.impl}</artifactId>

            <scope>test</scope>

        </dependency>    

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.expressionevaluator.lib.impl</artifactId>

            <scope>test</scope>

        </dependency>    

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.expressionevaluator.geometry.lib.impl</artifactId>

            <scope>test</scope>

        </dependency>    

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>${org.gvsig.proj.lib.impl}</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.compat.se</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.metadata.lib.basic.impl</artifactId>

            <scope>test</scope>

        </dependency>      

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.timesupport.lib.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.file.csv</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.util.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.swing.impl</artifactId>

            <scope>test</scope>

        </dependency>

    </dependencies>

    <build>

        <plugins>

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-surefire-plugin</artifactId>

                <configuration>

                    <!-- Skip test execution ? -->

                    <skipTests>false</skipTests>

                    <!-- Ignore test execution failure ? -->

                    <testFailureIgnore>true</testFailureIgnore>

                </configuration>

            </plugin>

            <!-- Skip test compilation ? -->

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-compiler-plugin</artifactId>

                <executions>

                    <execution>

                        <id>default-testCompile</id>

                        <phase>process-test-sources</phase>

                        <goals>

                            <goal>testCompile</goal>

                        </goals>

                        <configuration>

                            <skip>false</skip>

                        </configuration>

                    </execution>

                </executions>

            </plugin>

        </plugins>

    </build>

</project>

#Thu Nov 25 20:27:03 CET 2021

buildNumber=43

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.vcsgis.app.server;

import java.sql.Timestamp;

import java.time.LocalDate;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import junit.framework.TestCase;

import static junit.framework.TestCase.assertEquals;

import static junit.framework.TestCase.assertNotNull;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.fmap.dal.exception.DataException;

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

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

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

import static org.gvsig.tools.dataTypes.DataTypeUtils.toTimestamp;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.util.GetItemWithSize64;

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

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

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

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

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

/**

 *

 * @author fdiaz

 */

public class TestCommons {

    public static void test_add(VCSGisWorkspace ws) throws Exception {

        FeatureStore sourceTest = TestUtils.openSourceStore2();

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

        DisposeUtils.disposeQuietly(sourceTest);        

        TestCase.assertEquals("ws.add status", ERR_NO_ERROR, r);

    }

    public static void test_insert(FeatureStore store, int id, String text) throws DataException{

        EditableFeature ef = store.createNewFeature();

        ef.set("id",id);

        ef.set("text",text);

        store.insert(ef);

    }

    public static void test_update(FeatureStore store, int id, String text) throws DataException{

        Feature f = store.findFirst("id="+id);

        EditableFeature ef = f.getEditable();

        ef.set("text", text);

        store.update(ef);

    }

    public static void test_delete(FeatureStore store, int id, String text) throws DataException{

        Feature f = store.findFirst("id="+id);

        store.delete(f);

    }

    public static void test_check(List<Feature> features, int index, int id, String text){

        TestCase.assertEquals(id    , features.get(index).getInt("id"));

        TestCase.assertEquals(text, features.get(index).getString("text"));

    }

    public static void test_check(FeatureStore store2, String relatedFeatureCode, int id, String text) throws Exception {

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

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

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

    }

    public static void test_checkall(VCSGisWorkspace ws, Object... values) throws Exception {

        FeatureStore store = ws.openFeatureStore("test",false);

        assertEquals("ws test-size", values.length/2, store.size64());

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

        int index = 0;

        for (int i = 0; i < values.length; i+=2) {

            int id = (int) values[i];

            String text = (String) values[i+1];

            TestCase.assertEquals(id    , features.get(index).getInt("id"));

            TestCase.assertEquals(text, features.get(index).getString("text"));

            index++;

        }

        DisposeUtils.disposeQuietly(store);

    }

    public static void test_modify(VCSGisWorkspace ws, Object... values) throws Exception {

        FeatureStore store = ws.openFeatureStore("test",false);

        store.edit();

        for (int i = 0; i < values.length; i+=3) {

            String operation = (String) values[i];

            int id = (int) values[i+1];

            String text = (String) values[i+2];

            switch(operation.toLowerCase()) {

                case "insert":

                    test_insert(store, id, text);

                    break;

                case "update":

                    test_update(store, id, text);

                    break;

                case "delete":

                    test_delete(store, id, text);

                    break;

                default:

                    TestCase.assertTrue("Illegal argument", false);

            }

        }

        store.finishEditing();

        DisposeUtils.disposeQuietly(store);

    }

    public static void test_updatePrepare(VCSGisWorkspace ws) {

        int r = ws.updatePrepare("test");

        assertEquals("ws.updatePrepare status", ERR_NO_ERROR, r);

    }

    public static void test_update(VCSGisWorkspace ws) {

        int r = ws.update("test");

        assertEquals("ws.update status", ERR_NO_ERROR, r);

    }

    public static void test_checkout(VCSGisWorkspace ws) {

        int r = ws.checkout("test");

        assertEquals("ws.checkout status", ERR_NO_ERROR, r);

    }

    public static void test_merge(VCSGisWorkspace ws) {

        int r = ws.merge("test");

        assertEquals("ws.merge status", ERR_NO_ERROR, r);

    }

    public static void test_commit(VCSGisWorkspace ws) {

        int r = ws.commit();

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

    }

    public static void test_commit(VCSGisWorkspace ws, Timestamp revisionDate, Timestamp efectiveDate, String comment) {

        int r = ws.commit(revisionDate, efectiveDate, comment, null);

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

    }

    public static void test_commit(VCSGisWorkspace ws, LocalDate revisionDate, LocalDate efectiveDate, String comment) {

        int r = ws.commit(toTimestamp(revisionDate), toTimestamp(efectiveDate), comment, null);

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

    }

    public static void test_commit(VCSGisWorkspace ws, int expectedStatus) {

        int r = ws.commit();

        assertEquals("ws.commit status", expectedStatus, r);

    }

    public static void test_checklocalchanges(VCSGisWorkspace ws, Object... values) {

        class Value { 

            int operation; int id; String text; String relatedFeatureCode; 

            @Override

            public String toString() {

                return String.format("op=%d id=%d text='%s' rfc='%s'", operation, id, text, relatedFeatureCode);

            }

        }

        GetItemWithSize64<VCSGisWorkspaceChange> localChanges = ws.getLocalChanges(); 

        if( values == null ) {

            assertEquals("localChangesSize", 0, localChanges.size64());

            return;

        }

        assertEquals("localChangesSize", values.length/3, localChanges.size64());

        List<Value> changes = new ArrayList<>();

        Map<String,Value> changes_text = new HashMap<>();

        Map<Integer,Value> changes_id = new HashMap<>();

        for(long i = 0; i<localChanges.size64(); i++){

            VCSGisWorkspaceChange change = localChanges.get64(i);    

            Value value = new Value();

            value.relatedFeatureCode = change.getRelatedFeatureCode();

            value.operation = change.getOperation();

            try {

                Feature rf = change.getRelatedFeature();

                if( rf == null ) {

                    value.id = -1;

                    value.text = null;

                } else {

                    value.id = rf.getInt("id");

                    value.text = rf.getString("text");

                }

            } catch(Exception ex) {

                value.id = -1;

                value.text = change.getLabel();

            }

            changes_text.put(value.text, value);

            changes_id.put(value.id, value);

            changes.add(value);

        }

        for (int i = 0; i < values.length; i+=3 ) {

            int operation = (int) values[i+0];

            int id = (int) values[i+1];

            String text = (String) values[i+2];

            Value change;

            if( operation == OP_DELETE ) {

                change = changes_text.get(text);

                assertNotNull(change);

                assertEquals(text, change.text);

                assertEquals(operation, change.operation);

            } else {

                change = changes_id.get(id);

                assertNotNull(change);

                assertEquals(text, change.text);

                assertEquals(id, change.id);

                assertEquals(operation, change.operation);

            }

        }

    }

    public static void test_selectallremotechanges(VCSGisWorkspace ws) throws Exception {

        FeatureStore store = ws.openFeatureStore(RemoteChangesTable.TABLE_NAME,false);

        store.edit();

        store.update(RemoteChangesTable.SELECTED, true);

        store.finishEditing();

    }

    public static void test_revert(VCSGisWorkspace ws, String entityNameOrCode) {

        int r = ws.revert(entityNameOrCode);

        assertEquals("ws.revert status", ERR_NO_ERROR, r);

    }

}

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

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 = TestUtils.getServerExplorerParameters("srv-" + testid);

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

            TestUtils.h2sql_workspace(ws);

            FeatureStore sourceStore = TestUtils.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.

        VCSGisRepositoryLocaldb repositoryLocal = (VCSGisRepositoryLocaldb) 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.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.VCSGisRepositoryLocaldb;

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 = TestUtils.getServerExplorerParameters("srv-" + testid);

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

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

        enableAuthentication(repositoryLocal);

        repositoryLocal.dispose();

        Server server = TestUtils.createServer(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);

            TestUtils.h2sql_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 = TestUtils.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(VCSGisRepositoryLocaldb 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.exception.DataException;

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

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

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

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

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

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

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 void insert(FeatureStore store, int id, String text) throws DataException {

        EditableFeature ef = store.createNewFeature();

        ef.set("id", id);

        ef.set("text", text);

        store.insert(ef);

    }

    private void update(FeatureStore store, int id, String text) throws DataException {

        Feature f = store.findFirst("id=" + id);

        EditableFeature ef = f.getEditable();

        ef.set("text", text);

        store.update(ef);

    }

    private void delete(FeatureStore store, int id, String text) throws DataException {

        Feature f = store.findFirst("id=" + id);

        store.delete(f);

    }

    private void check(List<Feature> features, int index, int id, String text) {

        assertEquals(id, features.get(index).getInt("id"));

        assertEquals(text, features.get(index).getString("text"));

    }

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

    }

    private void selectRemoteChange(VCSGisWorkspace ws, boolean select, int id, String text, VCSGisWorkspace wsSource) throws Exception {

        Feature fTest;

        FeatureStore testStore = ws.openFeatureStore("test",false);

        FeatureStore testStoreSource = wsSource.openFeatureStore("test",false);

        fTest = testStoreSource.findFirst("id = " + id);

        FeatureStore rchangesStore = ws.openFeatureStore(RemoteChangesTable.TABLE_NAME,false);

        Feature fChanges = rchangesStore.findFirst("RCH_DATACODE = '" + fTest.getString(FEATURECODE_FIELD_NAME) + "'");

        EditableFeature efChanges = fChanges.getEditable();

        rchangesStore.edit(MODE_PASS_THROUGH);

        efChanges.set("RCH_SELECTED", select);

        rchangesStore.update(efChanges);

        rchangesStore.finishEditing();

        DisposeUtils.dispose(testStore);

        DisposeUtils.dispose(testStoreSource);

        DisposeUtils.dispose(rchangesStore);

    }

    private void checkLocalChange(FeatureStore data, FeatureStore changes, String code, int operation, int id, String text, int status) throws DataException {

        Feature change = changes.findFirst("WSCH_FEATURECODE = '" + code + "'");

        assertNotNull("Change code not exists", change);

        assertEquals(operation, change.getInt(WorkspaceChangesTable.OPERATION));

        if (status >= 0) {

            assertEquals(status, change.getInt(WorkspaceChangesTable.STATUS));

        }

        // Uf, ojo con operation delete, no tiene data. en la primera pasada lo saltaria, y a ver que pasa con

        // los inserts y updates.

//        if(operation != OP_DELETE){

//            Feature f = data.findFirst("VCSGISCODE = '"+code+"'");

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

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

//        }

    }

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

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

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

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

        repositoryLocal.setAllowAssignTheRevisionDate(true);

        TestUtils.h2sql_repository(repositoryLocal);

        repositoryLocal.dispose();

        server = TestUtils.createServer(explorerParams);

        server.start();

        VCSGisRepository repo = vcsgismanager.openRepository(serverUrl);

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

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

        File ws3file = TestUtils.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);

        TestUtils.h2sql_workspace(ws1);

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

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

        //REV 0

        FeatureStore sourceTest = TestUtils.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);

        TestUtils.h2sql_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);

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BBB");

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

        TestUtils.h2sql_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);

        check(features, 0, 1, "AAA");

        check(features, 1, 2, "BBB");

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

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

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

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

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

            check(features, 0, 1, "AAA");

            check(features, 1, 2, "BBB");

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

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

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

            //Seleccionar el cambio conflictivo id=4

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

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

            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

            checkLocalChange(store2, changes, "00000000000035abcdef0123456789", 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

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

            check(features, 0, 1, "AAA");

            check(features, 1, 2, "BBB");

            check(features, 2, 3, "CCC");

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

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

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

            check(features, 0, 1, "AAA");

            check(features, 1, 2, "BBB");

            check(features, 2, 3, "CCC");

            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

            checkLocalChange(store2, changes, "00000000000027abcdef0123456789", 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

            checkLocalChange(store2, changes, "00000000000035abcdef0123456789", 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();

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

            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

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

            check(features, 0, 1, "AAA");

            check(features, 1, 2, "BBB");

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

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

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

            check(features, 0, 1, "AAA");

            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.io.OutputStreamWriter;

import java.net.URL;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import static junit.framework.Assert.assertEquals;

import org.apache.commons.io.FileUtils;

import org.apache.commons.lang3.StringUtils;

import org.eclipse.jetty.server.Server;

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

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

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

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

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DatabaseWorkspaceManager;

import org.gvsig.fmap.dal.exception.DataException;

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.feature.impl.DefaultFeature;

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

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

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

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