gvSIG projects pool

package org.gvsig.vcsgis.lib.impl;

import java.util.Collections;

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.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_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.JDBCStoreParameters;

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

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

import org.gvsig.tools.util.ListBuilder;

import org.gvsig.tools.util.MapBuilder;

import org.gvsig.vcsgis.lib.VCSGisLocator;

import org.gvsig.vcsgis.lib.VCSGisManager;

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

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

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

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

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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class Test01InitRepo extends TestCase {

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

    public Test01InitRepo(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    private static class ExpectedValue implements Comparable<ExpectedValue>{

        private final String tableName;

        private final FeatureType featureType;

        public ExpectedValue(String tableName, FeatureType featureType) {

            this.tableName = tableName;

            this.featureType = featureType;

        }

        @Override

        public int compareTo(ExpectedValue o) {

            return this.tableName.compareTo(o.tableName);

        }

    }

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

    // public void testHello() {}

    public void testInit1() throws Exception {

        final String testid = "initrepo";

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

        VCSGisManager vcsgismanager = VCSGisLocator.getVCSGisManager();

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

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

        TestUtils.h2sql_repository(server);

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

        Collections.sort(tables, (DataStoreParameters o1, DataStoreParameters o2) -> StringUtils.compare(

                ((JDBCStoreParameters) o1).getTable(),

                ((JDBCStoreParameters) o2).getTable()

        ));

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

                .add(DataRepoTable.TABLE_NAME, new ExpectedValue(DataRepoTable.TABLE_NAME,DataRepoTable.featureType()))

                .add(EntitiesRepoTable.TABLE_NAME,new ExpectedValue(EntitiesRepoTable.TABLE_NAME,EntitiesRepoTable.featureType()))

                .add(HooksRepoTable.TABLE_NAME, new ExpectedValue(HooksRepoTable.TABLE_NAME,HooksRepoTable.featureType()))

                .add(RevisionsRepoTable.TABLE_NAME,new ExpectedValue(RevisionsRepoTable.TABLE_NAME,RevisionsRepoTable.featureType()))

                .add(ConfigRepoTable.TABLE_NAME,new ExpectedValue(ConfigRepoTable.TABLE_NAME,ConfigRepoTable.featureType()))

                .add(TopologyplanRepoTable.TABLE_NAME,new ExpectedValue(TopologyplanRepoTable.TABLE_NAME,TopologyplanRepoTable.featureType()))

                .add(UsersRepoTable.TABLE_NAME,new ExpectedValue(UsersRepoTable.TABLE_NAME,UsersRepoTable.featureType()))

                .add(ResourcesRepoTable.TABLE_NAME,new ExpectedValue(ResourcesRepoTable.TABLE_NAME,ResourcesRepoTable.featureType()))

                .add(TABLE_CONFIGURATION_NAME,new ExpectedValue(TABLE_CONFIGURATION_NAME,null))

//                .add(TABLE_REPOSITORY_NAME,new ExpectedValue(TABLE_REPOSITORY_NAME,null))

                .add(TABLE_RESOURCES_NAME,new ExpectedValue(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("VCSGISREPO_") && !tableName.startsWith("GVSIGD_")) {

                continue;

            }

            assertNotNull(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("VCSGISREPO_") && !tableName.startsWith("GVSIGD_")) {

                continue;

            }

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

            FeatureType expectedFeatureType = expectedTables.get(tableName).featureType;

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

        }

    }

}