/**
* Copyright (c) Codice Foundation
* <p>
* This is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser
* General Public License as published by the Free Software Foundation, either version 3 of the
* License, or any later version.
* <p>
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
* even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details. A copy of the GNU Lesser General Public License
* is distributed along with this program and can be found at
* <http://www.gnu.org/licenses/lgpl.html>.
*/
package ddf.catalog.extensiblemetacard;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.util.HashSet;
import java.util.Set;
import org.junit.BeforeClass;
import org.junit.Test;
import org.osgi.framework.InvalidSyntaxException;
import ddf.catalog.data.AttributeDescriptor;
import ddf.catalog.data.Metacard;
import ddf.catalog.data.MetacardTypeRegistry;
import ddf.catalog.data.MetacardTypeUnregistrationException;
import ddf.catalog.data.QualifiedMetacardType;
import ddf.catalog.data.impl.AttributeDescriptorImpl;
import ddf.catalog.data.impl.BasicTypes;
import ddf.catalog.data.impl.QualifiedMetacardTypeImpl;
import ddf.catalog.data.metacardtype.MetacardTypeRegistryImpl;
public class MetacardTypeRegistryTest {
public static final long SAMPLE_A_FREQUENCY = 14000000;
public static final long SAMPLE_A_MIN_FREQUENCY = 10000000;
public static final long SAMPLE_A_MAX_FREQUENCY = 20000000;
public static final int SAMPLE_A_ANGLE = 180;
public static final String DEFAULT_TITLE = "myTitle";
public static final String DEFAULT_ID = "myId";
public static final String DEFAULT_VERSION = "myVersion";
public static final String DEFAULT_TYPE = "myType";
public static final byte[] DEFAULT_BYTES = {8};
// Constants for Sample Metacard A defined below
private static final String ANGLE_ATTRIBUTE_NAME_SAMPLE_METACARD_TYPE_A = "angle";
private static final String MAX_FREQUENCY_ATTRIBUTE_NAME_SAMPLE_METACARD_TYPE_A =
"max-frequency";
private static final String MIN_FREQUENCY_ATTRIBUTE_NAME_SAMPLE_METACARD_TYPE_A =
"min-frequency";
private static final String FREQUENCY_ATTRIBUTE_NAME_SAMPLE_METACARD_TYPE_A = "frequency";
private static final int NUM_ATTRIBUTES_SAMPLE_METACARD_TYPE_A = 6;
private static final String SAMPLE_A_METACARD_TYPE_NAME = "MetacardTypeA";
// Constants for Sample Metacard B defined below
private static final String NUMBER_REVIEWERS_ATTRIBUTE_KEY = "number-reviewers";
private static final String PRECISE_HEIGHT_METERS_ATTRIBUTE_KEY = "precise-height-meters";
private static final String REVIEWED_ATTRIBUTE_KEY = "reviewed";
private static final String PRECISE_LENGTH_METERS_ATTRIBUTE_KEY = "precise-length-meters";
private static final String DESCRIPTION_ATTRIBUTE_KEY = "description";
private static final String ROWS_ATTRIBUTE_KEY = "rows";
private static final String COLUMNS_ATTRIBUTE_KEY = "columns";
private static final String SAMPLE_B_METACARD_TYPE_NAME = "MetacardTypeB";
private static final int NUM_ATTRIBUTES_SAMPLE_METACARD_TYPE_B = 9;
private static final String SAMPLE_B_METACARD_TYPE_NAMESPACE = "sample.b.namespace";
private static final String QUALIFIED_METACARD_TYPE_NAMESPACE_BAD = "namespace.bad";
private static final String QUALIFIED_METACARD_TYPE_NAME_BAD = "qmt-bad";
private static final String QUALIFIED_METACARD_TYPE_NAME_3 = "qmt3";
private static final String QUALIFIED_METACARD_TYPE_NAME_2 = "qmt2";
private static final String METADATA_ATTRIBUTE_DESCRIPTOR_NAME = "metadata";
private static final String GEO_ATTRIBUTE_DESCRIPTOR_NAME = "geo";
private static final int QUALIFIED_METACARD_TYPE_DESCRIPTORS_SIZE = 2;
private static final String QUALIFIED_METACARD_TYPE_NAMESPACE_1 = "ddf.test.namespace";
private static final String QUALIFIED_METACARD_TYPE_NAME_1 = "qmt1";
private static final String DEFAULT_DESCRIPTION = "sample description";
private static final int DEFAULT_ROWS = 100;
private static final int DEFAULT_COLUMNS = 5;
private static final String DEFAULT_MODIFIED_DATE = "2012-09-01T00:09:19.368+0000";
private static final String DEFAULT_CREATED_DATE = "2012-08-01T00:09:19.368+0000";
private static final String DEFAULT_URI = "http://example.com";
private static final Object DEFAULT_EXPIRATION_DATE = "2013-09-01T00:09:19.368+0000";
private static final Object DEFAULT_EFFECTIVE_DATE = "2012-08-15T00:09:19.368+0000";
private static MetacardTypeRegistry mtr;
private static HashSet<AttributeDescriptor> qmtAttributes;
@BeforeClass
public static void setupMetacardTypeRegistry() throws Exception {
mtr = MetacardTypeRegistryImpl.getInstance();
qmtAttributes = new HashSet<AttributeDescriptor>();
AttributeDescriptor ad1 = new AttributeDescriptorImpl(GEO_ATTRIBUTE_DESCRIPTOR_NAME,
true,
true,
false,
false,
BasicTypes.GEO_TYPE);
qmtAttributes.add(ad1);
AttributeDescriptor ad2 = new AttributeDescriptorImpl(METADATA_ATTRIBUTE_DESCRIPTOR_NAME,
true,
true,
false,
false,
BasicTypes.XML_TYPE);
qmtAttributes.add(ad2);
QualifiedMetacardTypeImpl qmt1 = new QualifiedMetacardTypeImpl(
QUALIFIED_METACARD_TYPE_NAMESPACE_1,
QUALIFIED_METACARD_TYPE_NAME_1,
qmtAttributes);
mtr.register(qmt1);
QualifiedMetacardTypeImpl qmt2 = new QualifiedMetacardTypeImpl(
QUALIFIED_METACARD_TYPE_NAMESPACE_1,
QUALIFIED_METACARD_TYPE_NAME_2,
qmtAttributes);
mtr.register(qmt2);
QualifiedMetacardTypeImpl qmt3 =
new QualifiedMetacardTypeImpl(QualifiedMetacardType.DEFAULT_METACARD_TYPE_NAMESPACE,
QUALIFIED_METACARD_TYPE_NAME_3,
qmtAttributes);
mtr.register(qmt3);
}
private void assertOnExpectedMetacardTypeFields(QualifiedMetacardType qmtResult) {
Set<AttributeDescriptor> attributeDescriptors = qmtResult.getAttributeDescriptors();
assertNotNull(attributeDescriptors);
assertEquals(QUALIFIED_METACARD_TYPE_DESCRIPTORS_SIZE, attributeDescriptors.size());
AttributeDescriptor geoAD = qmtResult.getAttributeDescriptor(GEO_ATTRIBUTE_DESCRIPTOR_NAME);
assertNotNull(geoAD);
assertEquals(GEO_ATTRIBUTE_DESCRIPTOR_NAME, geoAD.getName());
AttributeDescriptor metadataAD = qmtResult.getAttributeDescriptor(
METADATA_ATTRIBUTE_DESCRIPTOR_NAME);
assertNotNull(metadataAD);
assertEquals(METADATA_ATTRIBUTE_DESCRIPTOR_NAME, metadataAD.getName());
}
@Test
public void testLookupMetacardType() {
QualifiedMetacardType qmtResult = mtr.lookup("ddf.test.namespace",
QUALIFIED_METACARD_TYPE_NAME_1);
assertNotNull(qmtResult);
assertEquals(QUALIFIED_METACARD_TYPE_NAME_1, qmtResult.getName());
assertEquals(QUALIFIED_METACARD_TYPE_NAMESPACE_1, qmtResult.getNamespace());
assertOnExpectedMetacardTypeFields(qmtResult);
}
@Test(expected = IllegalArgumentException.class)
public void testLookupMetacardTypeNullNamespace() {
mtr.lookup(null, QUALIFIED_METACARD_TYPE_NAME_3);
}
@Test
public void testLookupMetacardTypeEmptyNamespace() {
QualifiedMetacardType qmtResult = mtr.lookup("", QUALIFIED_METACARD_TYPE_NAME_3);
assertNotNull(qmtResult);
assertEquals(QUALIFIED_METACARD_TYPE_NAME_3, qmtResult.getName());
assertEquals("", qmtResult.getNamespace());
assertOnExpectedMetacardTypeFields(qmtResult);
}
@Test(expected = IllegalArgumentException.class)
public void testLookupMetacardTypeNullName() {
mtr.lookup(QUALIFIED_METACARD_TYPE_NAMESPACE_1, null);
}
@Test(expected = IllegalArgumentException.class)
public void testLookupMetacardTypeEmptyName() {
mtr.lookup(QUALIFIED_METACARD_TYPE_NAMESPACE_1, "");
}
@Test
public void testLookupMetacardTypeCantFindName() {
QualifiedMetacardType qmt = mtr.lookup(QUALIFIED_METACARD_TYPE_NAMESPACE_1,
QUALIFIED_METACARD_TYPE_NAME_BAD);
assertNull(qmt);
}
@Test
public void testLookupMetacardTypeCantFindNamespace() {
QualifiedMetacardType qmt = mtr.lookup(QUALIFIED_METACARD_TYPE_NAMESPACE_BAD,
QUALIFIED_METACARD_TYPE_NAME_3);
assertNull(qmt);
}
@Test
public void testNoNamespaceLookup() {
QualifiedMetacardType qmt = mtr.lookup(QUALIFIED_METACARD_TYPE_NAME_3);
assertNotNull(qmt);
assertEquals(QUALIFIED_METACARD_TYPE_NAME_3, qmt.getName());
assertEquals(QualifiedMetacardType.DEFAULT_METACARD_TYPE_NAMESPACE, qmt.getNamespace());
assertOnExpectedMetacardTypeFields(qmt);
}
@Test
public void testNoNamespaceLookupCantFindName() {
QualifiedMetacardType qmt = mtr.lookup(QUALIFIED_METACARD_TYPE_NAME_BAD);
assertNull(qmt);
}
@Test
public void testNoNamespaceLookupMatchingNameMismatchingNamespace() {
QualifiedMetacardType qmt = mtr.lookup(QUALIFIED_METACARD_TYPE_NAME_2);
assertNull(qmt);
}
@Test(expected = IllegalArgumentException.class)
public void testNoNamespaceLookupEmptyName() {
mtr.lookup("");
}
@Test(expected = IllegalArgumentException.class)
public void testNoNamespaceLookupNullName() {
mtr.lookup(null);
}
@Test
public void registerMetacardType() throws InvalidSyntaxException, IllegalArgumentException,
MetacardTypeUnregistrationException {
assertEquals(4,
mtr.getRegisteredTypes()
.size());
mtr.register(sampleMetacardTypeA());
mtr.register(sampleMetacardTypeB());
assertEquals(6,
mtr.getRegisteredTypes()
.size());
QualifiedMetacardType metacardTypeAFromRegistry =
mtr.lookup(QualifiedMetacardType.DEFAULT_METACARD_TYPE_NAMESPACE,
SAMPLE_A_METACARD_TYPE_NAME);
assertNotNull(metacardTypeAFromRegistry);
assertEquals(SAMPLE_A_METACARD_TYPE_NAME, metacardTypeAFromRegistry.getName());
assertEquals(QualifiedMetacardType.DEFAULT_METACARD_TYPE_NAMESPACE,
metacardTypeAFromRegistry.getNamespace());
assertOnSampleMetacardTypeAExpectedAttributes(metacardTypeAFromRegistry);
QualifiedMetacardType metacardTypeBFromRegistry = mtr.lookup(
SAMPLE_B_METACARD_TYPE_NAMESPACE,
SAMPLE_B_METACARD_TYPE_NAME);
assertNotNull(metacardTypeBFromRegistry);
assertEquals(SAMPLE_B_METACARD_TYPE_NAME, metacardTypeBFromRegistry.getName());
assertEquals(SAMPLE_B_METACARD_TYPE_NAMESPACE, metacardTypeBFromRegistry.getNamespace());
assertOnSampleMetacardTypeBExcpectedAttributes(metacardTypeBFromRegistry);
mtr.unregister(sampleMetacardTypeA());
mtr.unregister(sampleMetacardTypeB());
}
@Test
public void registerMetacardTypeNullNamespace()
throws IllegalArgumentException, MetacardTypeUnregistrationException {
QualifiedMetacardType qmt = new QualifiedMetacardTypeImpl(null,
QUALIFIED_METACARD_TYPE_NAME_1,
qmtAttributes);
mtr.register(qmt);
QualifiedMetacardType metacardTypeFromReg =
mtr.lookup(QualifiedMetacardType.DEFAULT_METACARD_TYPE_NAMESPACE,
QUALIFIED_METACARD_TYPE_NAME_1);
assertNotNull(metacardTypeFromReg);
assertEquals(QualifiedMetacardType.DEFAULT_METACARD_TYPE_NAMESPACE,
metacardTypeFromReg.getNamespace());
assertEquals(QUALIFIED_METACARD_TYPE_NAME_1, metacardTypeFromReg.getName());
mtr.unregister(qmt);
}
@Test
public void registerMetacardTypeEmptyNamepsace()
throws IllegalArgumentException, MetacardTypeUnregistrationException {
QualifiedMetacardType qmt = new QualifiedMetacardTypeImpl("",
QUALIFIED_METACARD_TYPE_NAME_1,
qmtAttributes);
mtr.register(qmt);
QualifiedMetacardType metacardTypeFromReg =
mtr.lookup(QualifiedMetacardType.DEFAULT_METACARD_TYPE_NAMESPACE,
QUALIFIED_METACARD_TYPE_NAME_1);
assertNotNull(metacardTypeFromReg);
assertEquals(QualifiedMetacardType.DEFAULT_METACARD_TYPE_NAMESPACE,
metacardTypeFromReg.getNamespace());
assertEquals(QUALIFIED_METACARD_TYPE_NAME_1, metacardTypeFromReg.getName());
mtr.unregister(qmt);
}
@Test(expected = IllegalArgumentException.class)
public void registerMetacardTypeNull() {
mtr.register(null);
}
@Test(expected = IllegalArgumentException.class)
public void registerMetacardTypeNullName() {
QualifiedMetacardType qmt = new QualifiedMetacardTypeImpl(
QUALIFIED_METACARD_TYPE_NAMESPACE_1,
null,
qmtAttributes);
mtr.register(qmt);
}
@Test(expected = IllegalArgumentException.class)
public void registerMetacardTypeEmptyName() {
QualifiedMetacardType qmt = new QualifiedMetacardTypeImpl(
QUALIFIED_METACARD_TYPE_NAMESPACE_1,
"",
qmtAttributes);
mtr.register(qmt);
}
@Test
public void testRegisteredTypes() {
Set<QualifiedMetacardType> registeredTypes = mtr.getRegisteredTypes();
assertEquals(4, registeredTypes.size());
QualifiedMetacardTypeImpl test0 = new QualifiedMetacardTypeImpl(
QUALIFIED_METACARD_TYPE_NAMESPACE_1,
QUALIFIED_METACARD_TYPE_NAME_1,
qmtAttributes);
assertTrue(registeredTypes.contains(test0));
QualifiedMetacardTypeImpl test1 = new QualifiedMetacardTypeImpl(
QUALIFIED_METACARD_TYPE_NAMESPACE_1,
QUALIFIED_METACARD_TYPE_NAME_2,
qmtAttributes);
assertTrue(registeredTypes.contains(test1));
QualifiedMetacardTypeImpl test2 =
new QualifiedMetacardTypeImpl(QualifiedMetacardType.DEFAULT_METACARD_TYPE_NAMESPACE,
QUALIFIED_METACARD_TYPE_NAME_3,
qmtAttributes);
assertTrue(registeredTypes.contains(test2));
}
@Test
public void testUnregister()
throws IllegalArgumentException, MetacardTypeUnregistrationException {
assertEquals(4,
mtr.getRegisteredTypes()
.size());
mtr.register(sampleMetacardTypeA());
mtr.register(sampleMetacardTypeB());
assertEquals(6,
mtr.getRegisteredTypes()
.size());
QualifiedMetacardType metacardTypeAFromRegistry =
mtr.lookup(QualifiedMetacardType.DEFAULT_METACARD_TYPE_NAMESPACE,
SAMPLE_A_METACARD_TYPE_NAME);
assertNotNull(metacardTypeAFromRegistry);
assertEquals(SAMPLE_A_METACARD_TYPE_NAME, metacardTypeAFromRegistry.getName());
assertEquals(QualifiedMetacardType.DEFAULT_METACARD_TYPE_NAMESPACE,
metacardTypeAFromRegistry.getNamespace());
assertOnSampleMetacardTypeAExpectedAttributes(metacardTypeAFromRegistry);
QualifiedMetacardType metacardTypeBFromRegistry = mtr.lookup(
SAMPLE_B_METACARD_TYPE_NAMESPACE,
SAMPLE_B_METACARD_TYPE_NAME);
assertNotNull(metacardTypeBFromRegistry);
assertEquals(SAMPLE_B_METACARD_TYPE_NAME, metacardTypeBFromRegistry.getName());
assertEquals(SAMPLE_B_METACARD_TYPE_NAMESPACE, metacardTypeBFromRegistry.getNamespace());
assertOnSampleMetacardTypeBExcpectedAttributes(metacardTypeBFromRegistry);
mtr.unregister(sampleMetacardTypeA());
assertEquals(5,
mtr.getRegisteredTypes()
.size());
assertTrue(mtr.getRegisteredTypes()
.contains(sampleMetacardTypeB()));
assertFalse(mtr.getRegisteredTypes()
.contains(sampleMetacardTypeA()));
QualifiedMetacardTypeImpl qmt1 = new QualifiedMetacardTypeImpl(
QUALIFIED_METACARD_TYPE_NAMESPACE_1,
QUALIFIED_METACARD_TYPE_NAME_1,
qmtAttributes);
assertTrue(mtr.getRegisteredTypes()
.contains(qmt1));
QualifiedMetacardTypeImpl qmt2 = new QualifiedMetacardTypeImpl(
QUALIFIED_METACARD_TYPE_NAMESPACE_1,
QUALIFIED_METACARD_TYPE_NAME_2,
qmtAttributes);
assertTrue(mtr.getRegisteredTypes()
.contains(qmt2));
QualifiedMetacardTypeImpl qmt3 =
new QualifiedMetacardTypeImpl(QualifiedMetacardType.DEFAULT_METACARD_TYPE_NAMESPACE,
QUALIFIED_METACARD_TYPE_NAME_3,
qmtAttributes);
assertTrue(mtr.getRegisteredTypes()
.contains(qmt3));
mtr.unregister(sampleMetacardTypeB());
}
private QualifiedMetacardType sampleMetacardTypeA() {
Set<AttributeDescriptor> descriptors = new HashSet<AttributeDescriptor>();
descriptors.add(new AttributeDescriptorImpl(FREQUENCY_ATTRIBUTE_NAME_SAMPLE_METACARD_TYPE_A,
true /* indexed */,
true /* stored */,
false /* tokenized */,
false /* multivalued */,
BasicTypes.LONG_TYPE));
descriptors.add(new AttributeDescriptorImpl(
MIN_FREQUENCY_ATTRIBUTE_NAME_SAMPLE_METACARD_TYPE_A,
true /* indexed */,
true /* stored */,
false /* tokenized */,
false /* multivalued */,
BasicTypes.LONG_TYPE));
descriptors.add(new AttributeDescriptorImpl(
MAX_FREQUENCY_ATTRIBUTE_NAME_SAMPLE_METACARD_TYPE_A,
true /* indexed */,
true /* stored */,
false /* tokenized */,
false /* multivalued */,
BasicTypes.LONG_TYPE));
descriptors.add(new AttributeDescriptorImpl(ANGLE_ATTRIBUTE_NAME_SAMPLE_METACARD_TYPE_A,
true /* indexed */,
true /* stored */,
false /* tokenized */,
false /* multivalued */,
BasicTypes.INTEGER_TYPE));
descriptors.add(new AttributeDescriptorImpl(Metacard.ID,
true /* indexed */,
true /* stored */,
false /* tokenized */,
false /* multivalued */,
BasicTypes.STRING_TYPE));
descriptors.add(new AttributeDescriptorImpl(Metacard.TITLE,
true /* indexed */,
true /* stored */,
true /* tokenized */,
false /* multivalued */,
BasicTypes.STRING_TYPE));
return new QualifiedMetacardTypeImpl("", SAMPLE_A_METACARD_TYPE_NAME, descriptors);
}
private void assertOnSampleMetacardTypeAExpectedAttributes(QualifiedMetacardType qmtResult) {
Set<AttributeDescriptor> attributeDescriptors = qmtResult.getAttributeDescriptors();
assertNotNull(attributeDescriptors);
assertEquals(NUM_ATTRIBUTES_SAMPLE_METACARD_TYPE_A, attributeDescriptors.size());
AttributeDescriptor angle = qmtResult.getAttributeDescriptor(
ANGLE_ATTRIBUTE_NAME_SAMPLE_METACARD_TYPE_A);
assertNotNull(angle);
assertEquals(ANGLE_ATTRIBUTE_NAME_SAMPLE_METACARD_TYPE_A, angle.getName());
AttributeDescriptor maxFreq = qmtResult.getAttributeDescriptor(
MAX_FREQUENCY_ATTRIBUTE_NAME_SAMPLE_METACARD_TYPE_A);
assertNotNull(maxFreq);
assertEquals(MAX_FREQUENCY_ATTRIBUTE_NAME_SAMPLE_METACARD_TYPE_A, maxFreq.getName());
AttributeDescriptor minFreq = qmtResult.getAttributeDescriptor(
MIN_FREQUENCY_ATTRIBUTE_NAME_SAMPLE_METACARD_TYPE_A);
assertNotNull(minFreq);
assertEquals(MIN_FREQUENCY_ATTRIBUTE_NAME_SAMPLE_METACARD_TYPE_A, minFreq.getName());
AttributeDescriptor freq = qmtResult.getAttributeDescriptor(
FREQUENCY_ATTRIBUTE_NAME_SAMPLE_METACARD_TYPE_A);
assertNotNull(freq);
assertEquals(FREQUENCY_ATTRIBUTE_NAME_SAMPLE_METACARD_TYPE_A, freq.getName());
AttributeDescriptor metacardId = qmtResult.getAttributeDescriptor(Metacard.ID);
assertNotNull(metacardId);
assertEquals(Metacard.ID, metacardId.getName());
AttributeDescriptor metacardTitle = qmtResult.getAttributeDescriptor(Metacard.TITLE);
assertNotNull(metacardTitle);
assertEquals(Metacard.TITLE, metacardTitle.getName());
}
private QualifiedMetacardType sampleMetacardTypeB() {
Set<AttributeDescriptor> descriptors = new HashSet<AttributeDescriptor>();
descriptors.add(new AttributeDescriptorImpl(COLUMNS_ATTRIBUTE_KEY,
true /* indexed */,
true /* stored */,
false /* tokenized */,
false /* multivalued */,
BasicTypes.INTEGER_TYPE));
descriptors.add(new AttributeDescriptorImpl(ROWS_ATTRIBUTE_KEY,
true /* indexed */,
true /* stored */,
false /* tokenized */,
false /* multivalued */,
BasicTypes.INTEGER_TYPE));
descriptors.add(new AttributeDescriptorImpl(DESCRIPTION_ATTRIBUTE_KEY,
true /* indexed */,
true /* stored */,
false /* tokenized */,
false /* multivalued */,
BasicTypes.STRING_TYPE));
descriptors.add(new AttributeDescriptorImpl(Metacard.ID,
true /* indexed */,
true /* stored */,
false /* tokenized */,
false /* multivalued */,
BasicTypes.STRING_TYPE));
descriptors.add(new AttributeDescriptorImpl(Metacard.TITLE,
true /* indexed */,
true /* stored */,
true /* tokenized */,
false /* multivalued */,
BasicTypes.STRING_TYPE));
descriptors.add(new AttributeDescriptorImpl(REVIEWED_ATTRIBUTE_KEY,
true /* indexed */,
true /* stored */,
true /* tokenized */,
false /* multivalued */,
BasicTypes.BOOLEAN_TYPE));
descriptors.add(new AttributeDescriptorImpl(PRECISE_LENGTH_METERS_ATTRIBUTE_KEY,
true /* indexed */,
true /* stored */,
true /* tokenized */,
false /* multivalued */,
BasicTypes.DOUBLE_TYPE));
descriptors.add(new AttributeDescriptorImpl(PRECISE_HEIGHT_METERS_ATTRIBUTE_KEY,
true /* indexed */,
true /* stored */,
true /* tokenized */,
false /* multivalued */,
BasicTypes.FLOAT_TYPE));
descriptors.add(new AttributeDescriptorImpl(NUMBER_REVIEWERS_ATTRIBUTE_KEY,
true /* indexed */,
true /* stored */,
true /* tokenized */,
false /* multivalued */,
BasicTypes.SHORT_TYPE));
return new QualifiedMetacardTypeImpl(SAMPLE_B_METACARD_TYPE_NAMESPACE,
SAMPLE_B_METACARD_TYPE_NAME,
descriptors);
}
private void assertOnSampleMetacardTypeBExcpectedAttributes(QualifiedMetacardType qmt) {
Set<AttributeDescriptor> attributeDescriptors = qmt.getAttributeDescriptors();
assertNotNull(attributeDescriptors);
assertEquals(NUM_ATTRIBUTES_SAMPLE_METACARD_TYPE_B, attributeDescriptors.size());
AttributeDescriptor preciseHeight = qmt.getAttributeDescriptor(
PRECISE_HEIGHT_METERS_ATTRIBUTE_KEY);
assertNotNull(preciseHeight);
assertEquals(PRECISE_HEIGHT_METERS_ATTRIBUTE_KEY, preciseHeight.getName());
AttributeDescriptor reviewed = qmt.getAttributeDescriptor(REVIEWED_ATTRIBUTE_KEY);
assertNotNull(reviewed);
assertEquals(REVIEWED_ATTRIBUTE_KEY, reviewed.getName());
AttributeDescriptor preciseLength = qmt.getAttributeDescriptor(
PRECISE_LENGTH_METERS_ATTRIBUTE_KEY);
assertNotNull(preciseLength);
assertEquals(PRECISE_LENGTH_METERS_ATTRIBUTE_KEY, preciseLength.getName());
AttributeDescriptor description = qmt.getAttributeDescriptor(DESCRIPTION_ATTRIBUTE_KEY);
assertNotNull(description);
assertEquals(DESCRIPTION_ATTRIBUTE_KEY, description.getName());
AttributeDescriptor rows = qmt.getAttributeDescriptor(ROWS_ATTRIBUTE_KEY);
assertNotNull(rows);
assertEquals(ROWS_ATTRIBUTE_KEY, rows.getName());
AttributeDescriptor columns = qmt.getAttributeDescriptor(COLUMNS_ATTRIBUTE_KEY);
assertNotNull(columns);
assertEquals(COLUMNS_ATTRIBUTE_KEY, columns.getName());
AttributeDescriptor numReviewers =
qmt.getAttributeDescriptor(NUMBER_REVIEWERS_ATTRIBUTE_KEY);
assertNotNull(numReviewers);
assertEquals(NUMBER_REVIEWERS_ATTRIBUTE_KEY, numReviewers.getName());
AttributeDescriptor metacardId = qmt.getAttributeDescriptor(Metacard.ID);
assertNotNull(metacardId);
assertEquals(Metacard.ID, metacardId.getName());
AttributeDescriptor metacardTitle = qmt.getAttributeDescriptor(Metacard.TITLE);
assertNotNull(metacardTitle);
assertEquals(Metacard.TITLE, metacardTitle.getName());
}
}