/*
* Licensed to STRATIO (C) under one or more contributor license agreements.
* See the NOTICE file distributed with this work for additional information
* regarding copyright ownership. The STRATIO (C) licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package com.stratio.connector.commons.ftest.functionalMetadata;
import com.stratio.connector.commons.ftest.GenericConnectorTest;
import com.stratio.connector.commons.metadata.IndexMetadataBuilder;
import com.stratio.connector.commons.metadata.TableMetadataBuilder;
import com.stratio.crossdata.common.data.ClusterName;
import com.stratio.crossdata.common.data.ColumnName;
import com.stratio.crossdata.common.data.IndexName;
import com.stratio.crossdata.common.exceptions.ConnectorException;
import com.stratio.crossdata.common.exceptions.UnsupportedException;
import com.stratio.crossdata.common.metadata.*;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
public abstract class GenericDiscoverMetadataFT extends GenericConnectorTest {
protected static final String COLUMN_1 = "id";
protected static final String COLUMN_2 = "name";
protected static final String INDEX_NAME = "index1";
protected static final String SECOND_TABLE = "second_table";
protected static final String SECOND_TABLE_COLUMN = "column";
/**
* The Log.
*/
final Logger logger = LoggerFactory.getLogger(this.getClass());
protected TableMetadata tableMetadata = createTableMetadataWithIndex();
protected TableMetadata tableMetadataSecondary = createSimpleTableMetadata();
protected CatalogMetadata catalogMetadataProvided;
@Override
protected ClusterName getClusterName() {
return new ClusterName("discoverClusterName");
}
/**
* Tests: provideTableMetadata
*
* @throws UnsupportedException
* @throws ConnectorException
*/
@Override
public void setUp() throws ConnectorException {
super.setUp();
prepareEnvironment(tableMetadata);
prepareEnvironment(tableMetadataSecondary);
Iterator<CatalogMetadata> iteratorMetadata = getConnector().getMetadataEngine()
.provideMetadata(getClusterName()).iterator();
boolean catalogFound = false;
while (iteratorMetadata.hasNext() && !catalogFound) {
catalogMetadataProvided = iteratorMetadata.next();
catalogFound = catalogMetadataProvided.getName().getName().equals(CATALOG);
}
;
assertTrue("The catalog " + CATALOG + " must be recovered", catalogFound);
}
@Test
public void provideCatalogMetadataNamesFT() throws UnsupportedException, ConnectorException {
assertEquals("The catalog name is not the expected", CATALOG, catalogMetadataProvided.getName().getName());
assertEquals("There should be 2 tables", 2, catalogMetadataProvided.getTables().size());
TableMetadata tableWithIndexProvided = catalogMetadataProvided.getTables().get(tableMetadata.getName());
TableMetadata tableSimpleProvided = catalogMetadataProvided.getTables().get(tableMetadataSecondary.getName());
// Results verification
assertTrue("The table name is not the expected",
tableWithIndexProvided.getName().getName().equals(tableMetadata.getName().getName()));
assertTrue("The cluster name is not the expected",
tableWithIndexProvided.getClusterRef().getName().equals(getClusterName().getName()));
assertTrue("The table name is not the expected",
tableSimpleProvided.getName().getName().equals(tableMetadataSecondary.getName().getName()));
assertTrue("The cluster name is not the expected",
tableSimpleProvided.getClusterRef().getName().equals(getClusterName().getName()));
}
@Test
public void provideIndexMetadataFT() throws UnsupportedException, ConnectorException {
TableMetadata tableWithIndexProvided = catalogMetadataProvided.getTables().get(tableMetadata.getName());
TableMetadata tableSimpleProvided = catalogMetadataProvided.getTables().get(tableMetadataSecondary.getName());
verifyIndexMetadata(tableWithIndexProvided);
assertEquals("There should be no index", 0, tableSimpleProvided.getIndexes().size());
}
private void verifyIndexMetadata(TableMetadata tableMetadataProvided) {
assertTrue("The index has not been created", iConnectorHelper.containsIndex(CATALOG, TABLE, INDEX_NAME));
Map<IndexName, IndexMetadata> indexes = tableMetadataProvided.getIndexes();
assertTrue("The index has not been recovered", containsIndex(indexes));
IndexType typeProvided = resolveIndexType(indexes);
IndexType typeExpected = resolveIndexType(tableMetadata.getIndexes());
assertEquals("The type is not the expected", typeExpected, typeProvided);
Set<IndexName> keySet = tableMetadataProvided.getIndexes().keySet();
IndexMetadata indexMetadata = indexes.get(keySet.iterator().next());
assertEquals("The index should have 2 columns", 2, indexMetadata.getColumns().keySet().size());
Iterator<ColumnName> iterator = indexMetadata.getColumns().keySet().iterator();
assertEquals("First column in composite index is not the expected", COLUMN_1, iterator.next().getName());
assertEquals("Second column in composite index is not the expected", COLUMN_2, iterator.next().getName());
}
@Test
public void providePrimaryKeyFT() throws UnsupportedException, ConnectorException {
TableMetadata tableWithIndexProvided = catalogMetadataProvided.getTables().get(tableMetadata.getName());
TableMetadata tableSimpleProvided = catalogMetadataProvided.getTables().get(tableMetadataSecondary.getName());
assertEquals("The primary key should be " + COLUMN_1, COLUMN_1, tableWithIndexProvided.getPrimaryKey().get(0)
.getName());
assertEquals("The primary key should be " + SECOND_TABLE_COLUMN, SECOND_TABLE_COLUMN, tableSimpleProvided
.getPrimaryKey().get(0).getName());
}
@Test
public void provideFieldsFT() throws UnsupportedException, ConnectorException {
TableMetadata tableWithIndexProvided = catalogMetadataProvided.getTables().get(tableMetadata.getName());
TableMetadata tableSimpleProvided = catalogMetadataProvided.getTables().get(tableMetadataSecondary.getName());
// verifyAllRowWasInserted table1
assertEquals("The table must have 2 columns", 2, tableWithIndexProvided.getColumns().size());
String columnNameProvided_1 = tableWithIndexProvided.getColumns()
.get(new ColumnName(tableMetadata.getName(), COLUMN_1)).getName().getName();
assertEquals("The field " + COLUMN_1 + " has not been found", COLUMN_1, columnNameProvided_1);
String columnNameProvided_2 = tableWithIndexProvided.getColumns()
.get(new ColumnName(tableMetadata.getName(), COLUMN_2)).getName().getName();
assertEquals("The field " + COLUMN_2 + " has not been found", COLUMN_2, columnNameProvided_2);
// verifyAllRowWasInserted table2
assertEquals("The table must have 1 column", 1, tableSimpleProvided.getColumns().size());
columnNameProvided_1 = tableSimpleProvided.getColumns()
.get(new ColumnName(tableMetadataSecondary.getName(), SECOND_TABLE_COLUMN)).getName().getName();
assertEquals("The field " + SECOND_TABLE_COLUMN + " has not been found", SECOND_TABLE_COLUMN,
columnNameProvided_1);
}
protected boolean containsIndex(Map<IndexName, IndexMetadata> indexes) {
for (IndexName indexName : indexes.keySet()) {
if (indexName.getName().equals(INDEX_NAME)) {
return true;
}
}
return false;
}
protected IndexType resolveIndexType(Map<IndexName, IndexMetadata> indexList) {
IndexType typeProvided = null;
for (Entry<IndexName, IndexMetadata> indexName : indexList.entrySet()) {
if (indexName.getKey().getName().equals(INDEX_NAME)) {
typeProvided = indexName.getValue().getType();
}
}
return typeProvided;
}
protected abstract void prepareEnvironment(TableMetadata tableMetadata) throws ConnectorException;
private TableMetadata createTableMetadataWithIndex() {
TableMetadataBuilder tableMetadataBuilder = new TableMetadataBuilder(CATALOG, TABLE,
getClusterName().getName());
tableMetadataBuilder.addColumn(COLUMN_1,
new ColumnType(DataType.INT)).addColumn(COLUMN_2, new ColumnType(DataType.TEXT));
tableMetadataBuilder.withPartitionKey(COLUMN_1);
IndexMetadataBuilder indexMetadataBuilder = new IndexMetadataBuilder(CATALOG, TABLE, INDEX_NAME,
IndexType.DEFAULT);
indexMetadataBuilder.addColumn(COLUMN_1, new ColumnType(DataType.VARCHAR));
indexMetadataBuilder.addColumn(COLUMN_2, new ColumnType(DataType.TEXT));
IndexMetadata indexMetadata = indexMetadataBuilder.build();
tableMetadataBuilder.addIndex(indexMetadata);
tableMetadata = tableMetadataBuilder.build();
return tableMetadata;
}
private TableMetadata createSimpleTableMetadata() {
TableMetadataBuilder tableMetadataBuilder = new TableMetadataBuilder(CATALOG, SECOND_TABLE, getClusterName()
.getName());
tableMetadataBuilder.addColumn(SECOND_TABLE_COLUMN, new ColumnType(DataType.INT));
tableMetadataBuilder.withPartitionKey(SECOND_TABLE_COLUMN);
return tableMetadataBuilder.build();
}
}