Application: gvSIG desktop

package org.gvsig.fmap.dal.store.csv;

import java.io.File;

import java.net.URL;

import java.util.Date;

import java.util.List;

import junit.framework.TestCase;

import static junit.framework.TestCase.assertEquals;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemStoreParameters;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class TestCreate extends TestCase {

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

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

    protected File getTargetFolder() throws Exception {

        URL url = this.getClass().getResource("/");

        File x = new File(url.toURI());

        File target = x.getParentFile();

        return target;

    }

    protected File getFile(String name) throws Exception {

        File x = new File(getTargetFolder(), name);

        return x;

    }

    protected File getResource(String pathname) throws Exception {

        URL url = this.getClass().getResource(pathname);

        File x = new File(url.toURI());

        return x;

    }

    public FeatureStore openSourceStore1() throws Exception {

        DataManager dataManager = DALLocator.getDataManager();

        File f = getResource("/org/gvsig/fmap/dal/store/csv/testCreateSource1.csv");

        FeatureStore store = (FeatureStore) dataManager.openStore(

                DataStore.CSV_PROVIDER_NAME, 

                "file",f,

                "automaticTypesDetection", false,

                "locale","en"

        );

        return store;

    }

    protected String getProviderName() {

        return DataStore.CSV_PROVIDER_NAME;

    }

    protected String getTargetFilename() {

        return "testCreateTarget.csv";

    }

    protected FeatureStore openTargetStore1() throws Exception {

        DataManager dataManager = DALLocator.getDataManager();

        File f = getFile(getTargetFilename());

        FeatureStore store;

        try {

            store = (FeatureStore) dataManager.openStore(

                getProviderName(), 

                "file",f,

                "automaticTypesDetection", false,

                "locale","en"

            );

        } catch(Exception ex) {

            LOGGER.warn("Can't open TargetStore1("+f+")",ex);

            throw ex;

        }

        return store;

    }

    private void removeDALFile() throws Exception {

        File f = getFile(getTargetFilename());

        f = new File(FilenameUtils.removeExtension(f.getAbsolutePath())+".dal");

        FileUtils.deleteQuietly(f);

    }

    protected void createFrom(FeatureStore sourceStore) throws Exception {

        DataManager dataManager = DALLocator.getDataManager();

        DataServerExplorer explorer = dataManager.openServerExplorer(

                DataServerExplorer.FILESYSTEM_SERVER_EXPLORER_NAME, 

                "root", getTargetFolder()

        );

        NewFeatureStoreParameters params = (NewFeatureStoreParameters) explorer.getAddParameters(

                getProviderName()

        );

        ((FilesystemStoreParameters)params).setFile(getFile(getTargetFilename()));

        EditableFeatureType ft = params.getDefaultFeatureType();

        ft.copyFrom(sourceStore.getDefaultFeatureType());

        explorer.add(getProviderName(), params, true);

    }

    protected void checkTypes(FeatureType sourceFeatureType) throws Exception {

//        DataType STRING_TYPE = ToolsLocator.getDataTypesManager().get(DataTypes.STRING);

//        DataType INT_TYPE = ToolsLocator.getDataTypesManager().get(DataTypes.INT);

        FeatureStore targetStore = openTargetStore1();

        FeatureType targetFeatureType = targetStore.getDefaultFeatureType();

        assertEquals("Feature type size",sourceFeatureType.size(), targetFeatureType.size());

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

            FeatureAttributeDescriptor sourceAttr = sourceFeatureType.get(i);

            FeatureAttributeDescriptor targetAttr = targetFeatureType.get(i);

            switch(sourceAttr.getType()) {

                case DataTypes.BYTE:

                case DataTypes.INT:

                case DataTypes.LONG:

                case DataTypes.BOOLEAN:

                case DataTypes.DATE:

                case DataTypes.STRING:

                case DataTypes.TIME:

                case DataTypes.TIMESTAMP:

                case DataTypes.DOUBLE:

                case DataTypes.FLOAT:

                    assertEquals(

                            String.format("Field %s name mismatch", sourceAttr.getName()), 

                            sourceAttr.getName(), 

                            targetAttr.getName()

                    );

                    assertEquals(

                            String.format("Field %s type mismatch", sourceAttr.getName()), 

                            sourceAttr.getDataTypeName(), 

                            targetAttr.getDataTypeName()

                    );

                    assertEquals(

                            String.format("Field %s size mismatch", sourceAttr.getName()), 

                            sourceAttr.getSize(),

                            targetAttr.getSize()

                    );

                    assertEquals(

                            String.format("Field %s precision mismatch", sourceAttr.getName()), 

                            sourceAttr.getPrecision(),

                            targetAttr.getPrecision()

                    );

                    assertEquals(

                            String.format("Field %s precision mismatch", sourceAttr.getName()), 

                            sourceAttr.getScale(),

                            targetAttr.getScale()

                    );

                    break;

                case DataTypes.GEOMETRY:

                    assertEquals(

                            String.format("Field %s name mismatch", sourceAttr.getName()), 

                            sourceAttr.getName(), 

                            targetAttr.getName()

                    );

                    assertEquals(

                            String.format("Field %s type mismatch", sourceAttr.getName()), 

                            sourceAttr.getDataTypeName(), 

                            targetAttr.getDataTypeName()

                    );

                    assertEquals(

                            String.format("Field %s geometry type mismatch", sourceAttr.getName()), 

                            sourceAttr.getGeomType().getName(), 

                            targetAttr.getGeomType().getName()

                    );

                    assertEquals(

                            String.format("Field %s geometry SRS mismatch", sourceAttr.getName()), 

                            sourceAttr.getSRS().toString(), 

                            targetAttr.getSRS().toString()

                    );

                    assertEquals(

                            String.format("Field %s size mismatch", sourceAttr.getName()), 

                            sourceAttr.getSize(),

                            targetAttr.getSize()

                    );

                    assertEquals(

                            String.format("Field %s precision mismatch", sourceAttr.getName()), 

                            sourceAttr.getPrecision(),

                            targetAttr.getPrecision()

                    );

                    break;

                default:

                    fail(

                        String.format("Field %s type %d (%s) not supported.", 

                                targetAttr.getName(),

                                targetAttr.getType(),

                                targetAttr.getDataTypeName()

                        )

                    );

            }

        }

    }

    protected void copyFrom(FeatureStore sourceStore, int mode) throws Exception {

        FeatureStore targetStore = openTargetStore1();

        targetStore.edit(mode); // For debug

        int counter = 0;

        try {

            for (Feature sourceFeature : sourceStore.getFeatureSet()) {

                EditableFeature targetFeature = targetStore.createNewFeature(sourceFeature);

                targetStore.insert(targetFeature);

                counter++;

            }

        } finally {

            targetStore.finishEditing();

        }

    }

    protected void checkData(FeatureStore sourceStore) throws Exception {

        FeatureStore targetStore = openTargetStore1();

        List<Feature> sourceFeatures = sourceStore.getFeatures();

        List<Feature> targetFeatures = targetStore.getFeatures();

        assertEquals("Count features", sourceFeatures.size(), targetFeatures.size());

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

            Feature sourceFeature = sourceFeatures.get(i);

            Feature targetFeature = targetFeatures.get(i);

            for (FeatureAttributeDescriptor sourceAttr : sourceStore.getDefaultFeatureType()) {

                switch(sourceAttr.getType()) {

                    case DataTypes.BYTE:

                        assertEquals(

                                String.format("Feature %03d attribute %s", i, sourceAttr.getName()),

                                sourceFeature.getInt(sourceAttr.getName()),

                                targetFeature.getInt(sourceAttr.getName())

                        );

                        break;

                    case DataTypes.TIMESTAMP:

                        Date sourceTimestamp = sourceFeature.getDate(sourceAttr.getName());

                        Date targetTimestamp = targetFeature.getDate(sourceAttr.getName());

                        assertEquals(

                                String.format("Feature %03d attribute %s", i, sourceAttr.getName()),

                                sourceTimestamp,

                                targetTimestamp

                        );

                        break;

                    case DataTypes.TIME:

                        assertEquals(

                                String.format("Feature %03d attribute %s", i, sourceAttr.getName()),

                                sourceFeature.getDate(sourceAttr.getName()),

                                targetFeature.getDate(sourceAttr.getName())

                        );

                        break;

//                    case DataTypes.FLOAT:

//                    case DataTypes.DOUBLE:

//                        assertEquals(

//                                String.format("Feature %03d attribute %s", i, sourceAttr.getName()),

//                                sourceFeature.getDouble(sourceAttr.getName()),

//                                targetFeature.getDouble(sourceAttr.getName())

//                        );

//                        break;

                    case DataTypes.GEOMETRY:

                        assertEquals(

                                String.format("Feature %03d attribute %s", i, sourceAttr.getName()),

                                sourceFeature.get(sourceAttr.getName()),

                                targetFeature.get(sourceAttr.getName())

                        );

                        break;

                    case DataTypes.STRING:

                        assertEquals(

                                String.format("Feature %03d attribute %s", i, sourceAttr.getName()),

                                StringUtils.defaultIfBlank(sourceFeature.getString(sourceAttr.getName()), null),

                                StringUtils.defaultIfBlank(targetFeature.getString(sourceAttr.getName()), null)

                        );

                        break;

                    case DataTypes.INT:

                    case DataTypes.LONG:

                    case DataTypes.FLOAT:

                    case DataTypes.DOUBLE:

                    default:

                        Object sourceValue = sourceFeature.get(sourceAttr.getName());

                        Object targetValue = targetFeature.get(sourceAttr.getName());

                        if( sourceValue == null ) {

                            LOGGER.info("sourceValue is null");

                        }

                        assertEquals(

                                String.format("Feature %03d attribute %s", i, sourceAttr.getName()),

                                sourceValue,

                                targetValue

                        );

                }

            }

        }

    }

    public void testCreateWithDALFile() throws Exception {

        try {

            FeatureStore sourceStore = openSourceStore1();

            createFrom(sourceStore);

            checkTypes(sourceStore.getDefaultFeatureType());

            copyFrom(sourceStore, FeatureStore.MODE_APPEND);

            checkData(sourceStore);

            createFrom(sourceStore);

            copyFrom(sourceStore, FeatureStore.MODE_FULLEDIT);

            checkData(sourceStore);

        } catch (Exception e) {

            e.printStackTrace();

            throw e;

        }

    }

    public void testCreateWithoutDALFile() throws Exception {

        try {

            FeatureStore sourceStore = openSourceStore1();

            createFrom(sourceStore);        

            removeDALFile();

            checkTypes(sourceStore.getDefaultFeatureType());

            copyFrom(sourceStore, FeatureStore.MODE_APPEND);

            removeDALFile();

            checkData(sourceStore);

            createFrom(sourceStore);

            removeDALFile();

            copyFrom(sourceStore, FeatureStore.MODE_FULLEDIT);

            removeDALFile();

            checkData(sourceStore);

        } catch(Throwable t) {

            LOGGER.warn("",t);

            throw t;

        }

    }

    public void testCRLFAndQuotes() throws Exception {

        try {

            FeatureStore sourceStore = openSourceStore1();

            List<Feature> features = sourceStore.getFeatures();

            Feature f20 = features.get(19);

            Feature f21 = features.get(20);

            Feature f22 = features.get(21);

            Feature f23 = features.get(22);

            Feature f24 = features.get(23);

            Feature f25 = features.get(24);

            assertEquals("f20", "Yo \nyo20", f20.getString("String"));

            assertEquals("f21", "Yo \nyo21", f21.getString("String"));

            assertEquals("f22", "\nYo yo22", f22.getString("String"));

            // Ojo, es lo que hace ahora el lector de CSV, en este caso 

            // elimina las comillas dobles, aunque pensamos que deberia mantenerlas.

            // Si esto se corrige el test fallara y tendremos que evaluar el posible

            // impacto en otras partes del codigo.

            assertEquals("f23", "Yo yo23", f23.getString("String"));

            assertEquals("f24", "Yo \"yo24\"", f24.getString("String"));

            assertEquals("f25", "Yo\\n \"yo25\"", f25.getString("String"));

        } catch(Exception ex) {

            ex.printStackTrace();

            throw ex;

        }

    }

}