gvSIG projects pool

package org.gvsig.vcsgis.lib.impl;

import java.io.File;

import java.util.List;

import junit.framework.TestCase;

import static junit.framework.TestCase.assertEquals;

import org.apache.commons.io.FileUtils;

import org.codehaus.plexus.util.StringUtils;

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 org.gvsig.fmap.dal.store.jdbc2.JDBCServerExplorer;

import org.gvsig.tools.dispose.DisposeUtils;

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

import org.gvsig.vcsgis.lib.VCSGisEntity;

import org.gvsig.vcsgis.lib.VCSGisLocator;

import org.gvsig.vcsgis.lib.VCSGisManager;

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

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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class Test08Update extends TestCase {

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

    public Test08Update(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 testUpdate() throws Exception {

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

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

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

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

        int r;

        Feature f;

        EditableFeature ef;

        List<Feature> features;

        FeatureStore store1;

        FeatureStore store2;

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

        // Inicializamos el repositorio y lo abrimos

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

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

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

        TestUtils.h2sql_repository(repo);

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

        // Creamos workspace1 y lo abrimos.

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

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

        VCSGisWorkspace ws1 = manager.openWorkspace(ws1file);

        TestUtils.h2sql_workspace(ws1);

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

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

        FeatureStore sourceTest = TestUtils.openSourceStore2();

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

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

        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 = manager.initWorkspace(ws2file, repo, "Test update2",null);

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

        VCSGisWorkspace ws2 = manager.openWorkspace(ws2file);

        TestUtils.h2sql_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.getFeatureStore("test");

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

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

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

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

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

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

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

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

        DisposeUtils.disposeQuietly(store2);

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

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

        store1 = ws1.getFeatureStore("test");

        store1.edit();

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

        ef = f.getEditable();

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

        store1.update(ef);

        ef = store1.createNewFeature();

        ef.set("id",4);

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

        store1.insert(ef);

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit();

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

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

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

        // y comprobamos que tiene lo que toca.

        r = ws2.updatePrepare("test");

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

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

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

        r = ws2.updatePrepare("test");

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

        r = ws2.update("test");

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

        store2 = ws2.getFeatureStore("test");

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

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

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

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

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

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

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

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

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

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

        DisposeUtils.disposeQuietly(store2);

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

        // Volvemos a modificar la tabla "test" en el workspace1 y la commitamos.

        store1 = ws1.getFeatureStore("test");

        store1.edit();

        ef = store1.createNewFeature();

        ef.set("id",5);

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

        store1.insert(ef);

        f = store1.findFirst("id=3");

        store1.delete(f);        

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit();

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

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

        // Volvemos a actualizar (update) la tabla "test" en el workspace2

        // y comprobamos que tiene lo que toca.

        r = ws2.updatePrepare("test");

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

        r = ws2.update("test");

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

        store2 = ws2.getFeatureStore("test");

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

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

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

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

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

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

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

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

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

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

        DisposeUtils.disposeQuietly(store2);

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

        // Volvemos a modificar la tabla "test" en el workspace1 y la commitamos.

        store1 = ws1.getFeatureStore("test");

        store1.edit();

        ef = store1.createNewFeature();

        ef.set("id",6);

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

        store1.insert(ef);

        f = store1.findFirst("id=5");

        store1.delete(f);        

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit();

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

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

        // Volvemos a actualizar (update) la tabla "test" en el workspace2

        // y comprobamos que tiene lo que toca.

        r = ws2.updatePrepare("test");

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

        r = ws2.update("test");

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

        store2 = ws2.getFeatureStore("test");

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

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

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

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

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

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

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

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

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

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

        DisposeUtils.disposeQuietly(store2);

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

        // Volvemos a modificar la tabla "test" en el workspace1 y la commitamos.

        store1 = ws1.getFeatureStore("test");

        store1.edit();

        f = store1.findFirst("id=1");

        ef = f.getEditable();

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

        store1.update(ef);

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit();

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

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

        // Volvemos a actualizar (update) la tabla "test" en el workspace2

        // y comprobamos que tiene lo que toca.

        // Hemos generado varias revisiones, con modificaciones que incluyen

        // borrados y actualizaciones que afectan a varias de las revisiones, 

        // y comprobamos que al final se recuperan los datos del head correctamente.

        r = ws2.updatePrepare("test");

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

        r = ws2.update("test");

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

        store2 = ws2.getFeatureStore("test");

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

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

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

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

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

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

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

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

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

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

        DisposeUtils.disposeQuietly(store2);

    }

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

    }

    public void testUpdate2() throws Exception {

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

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

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

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

        int r;

        Feature f;

        EditableFeature ef;

        List<Feature> features;

        FeatureStore store1;

        FeatureStore store2;

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

        // Inicializamos el repositorio y lo abrimos

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

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

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

        TestUtils.h2sql_repository(repo);

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

        // Creamos workspace1 y lo abrimos.

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

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

        VCSGisWorkspace ws1 = manager.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);

        store1 = ws1.getFeatureStore("test");

        store1.edit();

        insert(store1, 4, "DDD");

        insert(store1, 5, "EEE");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit();

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

        //REV 1

        store1 = ws1.getFeatureStore("test");

        store1.edit();

        insert(store1, 6, "FFF");

        insert(store1, 7, "GGG");

        insert(store1, 8, "HHH");

        insert(store1, 9, "III");

        insert(store1, 10, "JJJ");

        delete(store1, 5, "EEE");

        update(store1, 2, "BB2");

        update(store1, 4, "DD2");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit();

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

        //REV 2

        store1 = ws1.getFeatureStore("test");

        store1.edit();

        insert(store1, 11, "KKK");

        insert(store1, 12, "LLL");

        insert(store1, 13, "MMM");

        delete(store1, 4, "DD2");

        delete(store1, 7, "GGG");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit();

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

        // UPDATE TO REV 2

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

        // Inicializamos el workspace2 asociandolo al mismo repositorio que 

        // workspace1 y lo abrimos.

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

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

        VCSGisWorkspace ws2 = manager.openWorkspace(ws2file);

        TestUtils.h2sql_workspace(ws2);

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

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

        // y comprobamos que tiene lo que toca.

        r = ws2.updatePrepare("test");

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

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

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

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

        assertEquals("ws2.update-1 changesSize", 10, changes.size64());

        for (int i = 0; i < changes.size64(); i++) {

            VCSGisRepositoryChange change = changes.get64(i);

            assertNotNull("ws2.update-1 label", change.getLabel());

            assertTrue("ws2.update-1 label", StringUtils.isNotBlank(change.getLabel()));

            String code = change.getEntityCode();

        }

        r = ws2.update("test");

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

        entity = ws2.getWorkspaceEntityByName("test");

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

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

        store2 = ws2.getFeatureStore("test");

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

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

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

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

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

        check(features, 3, 6, "FFF");

        check(features, 4, 8, "HHH");

        check(features, 5, 9, "III");

        check(features, 6, 10, "JJJ");

        check(features, 7, 11, "KKK");

        check(features, 8, 12, "LLL");

        check(features, 9, 13, "MMM");

        DisposeUtils.disposeQuietly(features);

        DisposeUtils.disposeQuietly(store2);

        //REV 3

        store1 = ws1.getFeatureStore("test");

        store1.edit();

        insert(store1, 14, "NNN");

        insert(store1, 15, "OOO");

        insert(store1, 16, "PPP");

        insert(store1, 17, "QQQ");

        delete(store1, 3, "CCC");

        delete(store1, 10, "JJJ");

        update(store1, 13, "MM2");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit();

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

        //REV 4

        store1 = ws1.getFeatureStore("test");

        store1.edit();

        insert(store1, 18, "RRR");

        insert(store1, 19, "SSS");

        insert(store1, 20, "TTT");

        insert(store1, 21, "UUU");

        delete(store1, 9, "III");

        update(store1, 17, "QQ2");

        delete(store1, 16, "PPP");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit();

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

        //REV 5

        store1 = ws1.getFeatureStore("test");

        store1.edit();

        insert(store1, 22, "VVV");

        insert(store1, 23, "WWW");

        insert(store1, 24, "XXX");

        insert(store1, 25, "YYY");

        insert(store1, 26, "ZZZ");

        delete(store1, 13, "MM2");

        delete(store1, 19, "SSS");

        store1.finishEditing();

        DisposeUtils.disposeQuietly(store1);

        r = ws1.commit();

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

        // UPDATE TO REV 5

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

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

        // y comprobamos que tiene lo que toca.

        r = ws2.updatePrepare("test");

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

        changes = ws2.getRemoteChanges();

        for (int i = 0; i < changes.size64(); i++) {

            VCSGisRepositoryChange change = changes.get64(i);

            assertNotNull("ws2.update-1 label", change.getLabel());

            assertTrue("ws2.update-1 label", StringUtils.isNotBlank(change.getLabel()));

            String code = change.getEntityCode();

        }

        assertEquals("ws2.update-1 changesSize", 15, changes.size64());

        r = ws2.update("test");

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

        store2 = ws2.getFeatureStore("test");

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

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

        int n=0;

        check(features, n++, 1, "AAA");

        check(features, n++, 2, "BB2");

        check(features, n++, 6, "FFF");

        check(features, n++, 8, "HHH");

        check(features, n++, 11, "KKK");

        check(features, n++, 12, "LLL");

        check(features, n++, 14, "NNN");

        check(features, n++, 15, "OOO");

        check(features, n++, 17, "QQ2");

        check(features, n++, 18, "RRR");

        check(features, n++, 20, "TTT");

        check(features, n++, 21, "UUU");

        check(features, n++, 22, "VVV");

        check(features, n++, 23, "WWW");

        check(features, n++, 24, "XXX");

        check(features, n++, 25, "YYY");

        check(features, n++, 26, "ZZZ");

        DisposeUtils.disposeQuietly(features);

        DisposeUtils.disposeQuietly(store2);

    }

}