gvSIG projects pool

package org.gvsig.vcsgis.lib.impl;

import java.io.File;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import junit.framework.TestCase;

import static junit.framework.TestCase.assertEquals;

import org.apache.commons.io.FileUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.util.MapBuilder;

import org.gvsig.vcsgis.lib.VCSGisLocator;

import org.gvsig.vcsgis.lib.VCSGisManager;

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

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

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

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

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

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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class Test02Initws extends TestCase {

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

    public Test02Initws(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 testCreateWS() throws Exception {

        String testid = "initws";

        VCSGisManager vcsgismanager = VCSGisLocator.getVCSGisManager();

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

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

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

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

        TestUtils.h2sql_repository(server);

        VCSGisRepository repo = vcsgismanager.openRepository(server);

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

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

        TestUtils.h2sql_workspace(wsfile);

        VCSGisWorkspace workspace = vcsgismanager.openWorkspace(wsfile);

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

        JDBCServerExplorer wsexplorer = TestUtils.openServerExplorer(wsfile);

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

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

            @Override

            public int compare(DataStoreParameters o1, DataStoreParameters o2) {

                return StringUtils.compare(

                        ((JDBCStoreParameters) o1).getTable(),

                        ((JDBCStoreParameters) o2).getTable()

                );

            }

        });

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

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

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

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

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

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

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

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

                .add(TABLE_CONFIGURATION_NAME,null)

                .add(TABLE_REPOSITORY_NAME,null)

                .add(TABLE_RESOURCES_NAME,null)

                .build();

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

        for (DataStoreParameters table : tables) {

            JDBCStoreParameters params = (JDBCStoreParameters) table;

            String tableName = params.getTable();

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

                continue;

            }

            assertTrue(expectedTables.containsKey(tableName));

            foundTableNames.add(tableName);

        }

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

            assertTrue(foundTableNames.contains(tableName));

        }

        DataManager dataManager = DALLocator.getDataManager();

        for (DataStoreParameters tableParams : tables) {

            JDBCStoreParameters params = (JDBCStoreParameters) tableParams;

            String tableName = params.getTable();

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

                continue;

            }

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

            FeatureType expectedFeatureType = expectedTables.get(tableName);

            if( expectedFeatureType!=null ) {

                FeatureType ft = store.getDefaultFeatureTypeQuietly();

                for (FeatureAttributeDescriptor expectedAttr : expectedFeatureType) {

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

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

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

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

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

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

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

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

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

                }

            }

            store.dispose();

        }

    }

}