Repository: incubator-atlas Updated Branches: refs/heads/master 3b1a7d09c -> ec1b160ac
http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/ec1b160a/webapp/src/test/java/org/apache/atlas/web/resources/EntityV2JerseyResourceIT.java ---------------------------------------------------------------------- diff --git a/webapp/src/test/java/org/apache/atlas/web/resources/EntityV2JerseyResourceIT.java b/webapp/src/test/java/org/apache/atlas/web/resources/EntityV2JerseyResourceIT.java new file mode 100755 index 0000000..c407130 --- /dev/null +++ b/webapp/src/test/java/org/apache/atlas/web/resources/EntityV2JerseyResourceIT.java @@ -0,0 +1,669 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF 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 + * <p/> + * http://www.apache.org/licenses/LICENSE-2.0 + * <p/> + * 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 org.apache.atlas.web.resources; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Lists; +import com.google.inject.Inject; +import com.sun.jersey.api.client.ClientResponse; +import org.apache.atlas.AtlasClient; +import org.apache.atlas.AtlasServiceException; +import org.apache.atlas.EntityAuditEvent; +import org.apache.atlas.model.instance.AtlasClassification; +import org.apache.atlas.model.instance.AtlasClassification.AtlasClassifications; +import org.apache.atlas.model.instance.AtlasEntity; +import org.apache.atlas.model.instance.AtlasEntityHeader; +import org.apache.atlas.model.instance.AtlasEntityWithAssociations; +import org.apache.atlas.model.instance.EntityMutationResponse; +import org.apache.atlas.model.instance.EntityMutations; +import org.apache.atlas.model.typedef.AtlasClassificationDef; +import org.apache.atlas.model.typedef.AtlasEntityDef; +import org.apache.atlas.model.typedef.AtlasTypesDef; +import org.apache.atlas.notification.NotificationConsumer; +import org.apache.atlas.notification.NotificationInterface; +import org.apache.atlas.notification.NotificationModule; +import org.apache.atlas.notification.entity.EntityNotification; +import org.apache.atlas.type.AtlasTypeUtil; +import org.apache.atlas.typesystem.types.TypeUtils; +import org.apache.commons.lang.RandomStringUtils; +import org.codehaus.jettison.json.JSONArray; +import org.joda.time.DateTime; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.testng.Assert; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.DataProvider; +import org.testng.annotations.Guice; +import org.testng.annotations.Test; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.testng.Assert.*; + + +/** + * Integration tests for Entity Jersey Resource. + */ +@Guice(modules = {NotificationModule.class}) +public class EntityV2JerseyResourceIT extends BaseResourceIT { + + private static final Logger LOG = LoggerFactory.getLogger(EntityV2JerseyResourceIT.class); + + private final String DATABASE_NAME = "db" + randomString(); + private final String TABLE_NAME = "table" + randomString(); + private static final String TRAITS = "traits"; + private static final String TRAIT_DEFINITION = "traitDefinitions"; + + private String traitName; + + private AtlasEntity dbEntity; + private AtlasEntityHeader dbEntityHeader; + private AtlasEntityWithAssociations tableEntity; + private AtlasEntityHeader tableEntityHeader; + + @Inject + private NotificationInterface notificationInterface; + private NotificationConsumer<EntityNotification> notificationConsumer; + + @BeforeClass + public void setUp() throws Exception { + super.setUp(); + + createTypeDefinitionsV2(); + + List<NotificationConsumer<EntityNotification>> consumers = + notificationInterface.createConsumers(NotificationInterface.NotificationType.ENTITIES, 1); + + notificationConsumer = consumers.iterator().next(); + } + + @Test + public void testSubmitEntity() throws Exception { + TypeUtils.Pair dbAndTable = createDBAndTable(DATABASE_NAME, TABLE_NAME); + assertNotNull(dbAndTable); + assertNotNull(dbAndTable.left); + assertNotNull(dbAndTable.right); + } + + @Test + public void testRequestUser() throws Exception { + AtlasEntity hiveDBInstanceV2 = createHiveDB(DATABASE_NAME); + List<EntityAuditEvent> events = atlasClientV1.getEntityAuditEvents(hiveDBInstanceV2.getGuid(), (short) 10); + assertTrue(events.size() > 1); + assertEquals(events.get(0).getUser(), "admin"); + } + + @Test + public void testEntityDeduping() throws Exception { + JSONArray results = searchByDSL(String.format("%s where name='%s'", DATABASE_TYPE, DATABASE_NAME)); + assertEquals(results.length(), 1); + + final AtlasEntity hiveDBInstanceV2 = createHiveDB(DATABASE_NAME); + // Do the notification thing here + waitForNotification(notificationConsumer, MAX_WAIT_TIME, new NotificationPredicate() { + @Override + public boolean evaluate(EntityNotification notification) throws Exception { + return notification != null && notification.getEntity().getId()._getId().equals(hiveDBInstanceV2.getGuid()); + } + }); + + + results = searchByDSL(String.format("%s where name='%s'", DATABASE_TYPE, DATABASE_NAME)); + assertEquals(results.length(), 1); + + //Test the same across references + final String tableName = randomString(); + AtlasEntityWithAssociations hiveTableInstanceV2 = createHiveTableInstanceV2(hiveDBInstanceV2, tableName); + hiveTableInstanceV2.setAttribute(AtlasClient.REFERENCEABLE_ATTRIBUTE_NAME, tableName); + + EntityMutationResponse entity = entitiesClientV2.createEntity(hiveTableInstanceV2); + assertNotNull(entity); + assertNotNull(entity.getEntitiesByOperation(EntityMutations.EntityOperation.CREATE_OR_UPDATE)); + results = searchByDSL(String.format("%s where name='%s'", DATABASE_TYPE, DATABASE_NAME)); + assertEquals(results.length(), 1); + } + + private void assertEntityAudit(String dbid, EntityAuditEvent.EntityAuditAction auditAction) + throws Exception { + List<EntityAuditEvent> events = atlasClientV1.getEntityAuditEvents(dbid, (short) 100); + for (EntityAuditEvent event : events) { + if (event.getAction() == auditAction) { + return; + } + } + fail("Expected audit event with action = " + auditAction); + } + + @Test + public void testEntityDefinitionAcrossTypeUpdate() throws Exception { + //create type + AtlasEntityDef entityDef = AtlasTypeUtil + .createClassTypeDef(randomString(), + ImmutableSet.<String>of(), + AtlasTypeUtil.createUniqueRequiredAttrDef("name", "string") + ); + AtlasTypesDef typesDef = new AtlasTypesDef(); + typesDef.getEntityDefs().add(entityDef); + + AtlasTypesDef created = typedefClientV2.createAtlasTypeDefs(typesDef); + assertNotNull(created); + assertNotNull(created.getEntityDefs()); + assertEquals(created.getEntityDefs().size(), 1); + + //create entity for the type + AtlasEntity instance = new AtlasEntity(entityDef.getName()); + instance.setAttribute("name", randomString()); + EntityMutationResponse mutationResponse = entitiesClientV2.createEntity(instance); + assertNotNull(mutationResponse); + assertNotNull(mutationResponse.getEntitiesByOperation(EntityMutations.EntityOperation.CREATE_OR_UPDATE)); + assertEquals(mutationResponse.getEntitiesByOperation(EntityMutations.EntityOperation.CREATE_OR_UPDATE).size(),1 ); + String guid = mutationResponse.getEntitiesByOperation(EntityMutations.EntityOperation.CREATE_OR_UPDATE).get(0).getGuid(); + + //update type - add attribute + entityDef = AtlasTypeUtil.createClassTypeDef(entityDef.getName(), ImmutableSet.<String>of(), + AtlasTypeUtil.createUniqueRequiredAttrDef("name", "string"), + AtlasTypeUtil.createOptionalAttrDef("description", "string")); + + typesDef = new AtlasTypesDef(); + typesDef.getEntityDefs().add(entityDef); + + AtlasTypesDef updated = typedefClientV2.updateAtlasTypeDefs(typesDef); + assertNotNull(updated); + assertNotNull(updated.getEntityDefs()); + assertEquals(updated.getEntityDefs().size(), 1); + + //Get definition after type update - new attributes should be null + AtlasEntity entityByGuid = entitiesClientV2.getEntityByGuid(guid); + assertNull(entityByGuid.getAttribute("description")); + assertEquals(entityByGuid.getAttribute("name"), instance.getAttribute("name")); + } + + @DataProvider + public Object[][] invalidAttrValues() { + return new Object[][]{{null}, {""}}; + } + + @Test(dataProvider = "invalidAttrValues") + public void testEntityInvalidValue(String value) throws Exception { + AtlasEntity databaseInstance = new AtlasEntity(DATABASE_TYPE); + String dbName = randomString(); + databaseInstance.setAttribute("name", dbName); + databaseInstance.setAttribute("description", value); + + AtlasEntityHeader created = createEntity(databaseInstance); + assertNull(created); + } + + @Test + public void testGetEntityByAttribute() throws Exception { + AtlasEntity hiveDB = createHiveDB(DATABASE_NAME); + String qualifiedName = (String) hiveDB.getAttribute(QUALIFIED_NAME); + //get entity by attribute + AtlasEntity byAttribute = entitiesClientV2.getEntityByAttribute(DATABASE_TYPE, QUALIFIED_NAME, qualifiedName); + assertEquals(byAttribute.getTypeName(), DATABASE_TYPE); + assertEquals(byAttribute.getAttribute(QUALIFIED_NAME), qualifiedName); + } + + @Test + public void testSubmitEntityWithBadDateFormat() throws Exception { + AtlasEntity hiveDBInstance = createHiveDBInstanceV2("db" + randomString()); + AtlasEntityHeader entity = createEntity(hiveDBInstance); + + AtlasEntity tableInstance = createHiveTableInstanceV2(hiveDBInstance, "table" + randomString()); + tableInstance.setAttribute("lastAccessTime", "2014-07-11"); + AtlasEntityHeader tableEntityHeader = createEntity(tableInstance); + assertNull(tableEntityHeader); + } + + @Test(dependsOnMethods = "testSubmitEntity") + public void testAddProperty() throws Exception { + //add property + String description = "bar table - new desc"; + addProperty(tableEntity.getGuid(), "description", description); + + AtlasEntity entityByGuid = entitiesClientV2.getEntityByGuid(tableEntity.getGuid()); + Assert.assertNotNull(entityByGuid); + + entityByGuid.setAttribute("description", description); + + // TODO: This behavior should've been consistent across APIs +// //invalid property for the type +// try { +// addProperty(table.getGuid(), "invalid_property", "bar table"); +// Assert.fail("Expected AtlasServiceException"); +// } catch (AtlasServiceException e) { +// assertNotNull(e.getStatus()); +// assertEquals(e.getStatus(), ClientResponse.Status.BAD_REQUEST); +// } + + //non-string property, update + String currentTime = String.valueOf(new DateTime()); + + + addProperty(tableEntity.getGuid(), "createTime", currentTime); + + entityByGuid = entitiesClientV2.getEntityByGuid(tableEntity.getGuid()); + Assert.assertNotNull(entityByGuid); + } + + @Test + public void testAddNullPropertyValue() throws Exception { + // FIXME: Behavior has changed between v1 and v2 + //add property +// try { + addProperty(tableEntity.getGuid(), "description", null); +// Assert.fail("Expected AtlasServiceException"); +// } catch(AtlasServiceException e) { +// Assert.assertEquals(e.getStatus().getStatusCode(), Response.Status.BAD_REQUEST.getStatusCode()); +// } + } + + @Test(expectedExceptions = AtlasServiceException.class) + public void testGetInvalidEntityDefinition() throws Exception { + entitiesClientV2.getEntityByGuid("blah"); + } + + @Test(dependsOnMethods = "testSubmitEntity", enabled = false) + public void testGetEntityList() throws Exception { + // TODO: Can only be done when there's a search API exposed from entity REST + } + + @Test(enabled = false) + public void testGetEntityListForBadEntityType() throws Exception { + // FIXME: Complete test when search interface is in place + } + + @Test(enabled = false) + public void testGetEntityListForNoInstances() throws Exception { + // FIXME: Complete test when search interface is in place + /* + String typeName = ""; + + ClientResponse clientResponse = + service.path(ENTITIES).queryParam("type", typeName).accept(Servlets.JSON_MEDIA_TYPE) + .type(Servlets.JSON_MEDIA_TYPE).method(HttpMethod.GET, ClientResponse.class); + Assert.assertEquals(clientResponse.getStatus(), Response.Status.OK.getStatusCode()); + + String responseAsString = clientResponse.getEntity(String.class); + Assert.assertNotNull(responseAsString); + + JSONObject response = new JSONObject(responseAsString); + Assert.assertNotNull(response.get(AtlasClient.REQUEST_ID)); + + final JSONArray list = response.getJSONArray(AtlasClient.RESULTS); + Assert.assertEquals(list.length(), 0); + */ + } + + private String addNewType() throws Exception { + String typeName = "test" + randomString(); + AtlasEntityDef classTypeDef = AtlasTypeUtil + .createClassTypeDef(typeName, ImmutableSet.<String>of(), + AtlasTypeUtil.createRequiredAttrDef("name", "string"), + AtlasTypeUtil.createRequiredAttrDef("description", "string")); + AtlasTypesDef typesDef = new AtlasTypesDef(); + typesDef.getEntityDefs().add(classTypeDef); + createType(typesDef); + return typeName; + } + + @Test(dependsOnMethods = "testSubmitEntity") + public void testGetTraitNames() throws Exception { + AtlasClassifications classifications = entitiesClientV2.getClassifications(tableEntity.getGuid()); + assertNotNull(classifications); + assertTrue(classifications.getList().size() > 0); + assertEquals(classifications.getList().size(), 8); + } + + private void addProperty(String guid, String property, String value) throws AtlasServiceException { + + AtlasEntity entityByGuid = entitiesClientV2.getEntityByGuid(guid); + entityByGuid.setAttribute(property, value); + EntityMutationResponse response = entitiesClientV2.updateEntity(entityByGuid); + assertNotNull(response); + assertNotNull(response.getEntitiesByOperation(EntityMutations.EntityOperation.CREATE_OR_UPDATE)); + } + + private AtlasEntity createHiveDB() { + if (dbEntity != null) { + return dbEntity; + } else { + return createHiveDB(DATABASE_NAME); + } + } + + private AtlasEntity createHiveDB(String dbName) { + AtlasEntity hiveDBInstanceV2 = createHiveDBInstanceV2(dbName); + AtlasEntityHeader entityHeader = createEntity(hiveDBInstanceV2); + assertNotNull(entityHeader); + assertNotNull(entityHeader.getGuid()); + hiveDBInstanceV2.setGuid(entityHeader.getGuid()); + dbEntity = hiveDBInstanceV2; + dbEntityHeader = entityHeader; + return hiveDBInstanceV2; + } + + private TypeUtils.Pair<AtlasEntity, AtlasEntityWithAssociations> createDBAndTable(String dbName, String tableName) throws Exception { + AtlasEntity dbInstanceV2 = createHiveDB(dbName); + AtlasEntityWithAssociations hiveTableInstanceV2 = createHiveTable(dbInstanceV2, tableName); + return TypeUtils.Pair.of(dbInstanceV2, hiveTableInstanceV2); + } + + private AtlasEntityWithAssociations createHiveTable() throws Exception { + if (tableEntity != null) { + return tableEntity; + } else { + return createHiveTable(createHiveDB(), TABLE_NAME); + } + } + + private AtlasEntityWithAssociations createHiveTable(AtlasEntity dbInstanceV2, String tableName) throws Exception { + AtlasEntityWithAssociations hiveTableInstanceV2 = createHiveTableInstanceV2(dbInstanceV2, tableName); + AtlasEntityHeader createdHeader = createEntity(hiveTableInstanceV2); + assertNotNull(createdHeader); + assertNotNull(createdHeader.getGuid()); + hiveTableInstanceV2.setGuid(createdHeader.getGuid()); + entitiesClientV2.addClassifications(createdHeader.getGuid(), hiveTableInstanceV2.getClassifications()); + tableEntity = hiveTableInstanceV2; + tableEntityHeader = createdHeader; + return hiveTableInstanceV2; + } + + @Test(dependsOnMethods = "testGetTraitNames") + public void testAddTrait() throws Exception { + traitName = "PII_Trait" + randomString(); + AtlasClassificationDef piiTrait = + AtlasTypeUtil.createTraitTypeDef(traitName, ImmutableSet.<String>of()); + AtlasTypesDef typesDef = new AtlasTypesDef(); + typesDef.getClassificationDefs().add(piiTrait); + createType(typesDef); + + entitiesClientV2.addClassifications(tableEntity.getGuid(), ImmutableList.of(new AtlasClassification(piiTrait.getName()))); + + assertEntityAudit(tableEntity.getGuid(), EntityAuditEvent.EntityAuditAction.TAG_ADD); + } + + @Test(dependsOnMethods = "testSubmitEntity") + public void testGetTraitDefinitionForEntity() throws Exception{ + traitName = "PII_Trait" + randomString(); + AtlasClassificationDef piiTrait = + AtlasTypeUtil.createTraitTypeDef(traitName, ImmutableSet.<String>of()); + AtlasTypesDef typesDef = new AtlasTypesDef(); + typesDef.getClassificationDefs().add(piiTrait); + createType(typesDef); + + AtlasClassificationDef classificationByName = typedefClientV2.getClassificationByName(traitName); + assertNotNull(classificationByName); + + assertEquals(tableEntity.getClassifications().size(), 7); + + AtlasClassification piiClassification = new AtlasClassification(piiTrait.getName()); + + entitiesClientV2.addClassifications(tableEntity.getGuid(), Lists.newArrayList(piiClassification)); + + AtlasClassifications classifications = entitiesClientV2.getClassifications(tableEntity.getGuid()); + assertNotNull(classifications); + assertTrue(classifications.getList().size() > 0); + assertEquals(classifications.getList().size(), 8); + } + + + @Test(dependsOnMethods = "testGetTraitNames") + public void testAddTraitWithAttribute() throws Exception { + final String traitName = "PII_Trait" + randomString(); + AtlasClassificationDef piiTrait = AtlasTypeUtil + .createTraitTypeDef(traitName, ImmutableSet.<String>of(), + AtlasTypeUtil.createRequiredAttrDef("type", "string")); + AtlasTypesDef typesDef = new AtlasTypesDef(); + typesDef.getClassificationDefs().add(piiTrait); + createType(typesDef); + + AtlasClassification traitInstance = new AtlasClassification(traitName); + traitInstance.setAttribute("type", "SSN"); + + final String guid = tableEntity.getGuid(); + entitiesClientV2.addClassifications(guid, ImmutableList.of(traitInstance)); + + // verify the response + AtlasEntityWithAssociations withAssociationByGuid = entitiesClientV2.getEntityWithAssociationByGuid(guid); + assertNotNull(withAssociationByGuid); + assertFalse(withAssociationByGuid.getClassifications().isEmpty()); + + boolean found = false; + for (AtlasClassification atlasClassification : withAssociationByGuid.getClassifications()) { + String attribute = (String)atlasClassification.getAttribute("type"); + if (attribute != null && attribute.equals("SSN")) { + found = true; + break; + } + } + assertTrue(found); + } + + @Test(expectedExceptions = AtlasServiceException.class) + public void testAddTraitWithNoRegistration() throws Exception { + final String traitName = "PII_Trait" + randomString(); + AtlasClassificationDef piiTrait = + AtlasTypeUtil.createTraitTypeDef(traitName, ImmutableSet.<String>of()); + + AtlasClassification traitInstance = new AtlasClassification(traitName); + + entitiesClientV2.addClassifications("random", ImmutableList.of(traitInstance)); + } + + @Test(dependsOnMethods = "testAddTrait") + public void testDeleteTrait() throws Exception { + final String guid = tableEntity.getGuid(); + + try { + entitiesClientV2.deleteClassification(guid, traitName); + } catch (AtlasServiceException ex) { + fail("Deletion should've succeeded"); + } + assertEntityAudit(guid, EntityAuditEvent.EntityAuditAction.TAG_DELETE); + } + + @Test + public void testDeleteTraitNonExistent() throws Exception { + final String traitName = "blah_trait"; + + try { + entitiesClientV2.deleteClassification("random", traitName); + fail("Deletion for bogus names shouldn't have succeeded"); + } catch (AtlasServiceException ex) { + assertNotNull(ex.getStatus()); +// assertEquals(ex.getStatus(), ClientResponse.Status.NOT_FOUND); + assertEquals(ex.getStatus(), ClientResponse.Status.BAD_REQUEST); + // Should it be a 400 or 404 + } + } + + @Test(dependsOnMethods = "testSubmitEntity") + public void testDeleteExistentTraitNonExistentForEntity() throws Exception { + + final String guid = tableEntity.getGuid(); + final String traitName = "PII_Trait" + randomString(); + AtlasClassificationDef piiTrait = AtlasTypeUtil + .createTraitTypeDef(traitName, ImmutableSet.<String>of(), + AtlasTypeUtil.createRequiredAttrDef("type", "string")); + AtlasTypesDef typesDef = new AtlasTypesDef(); + typesDef.getClassificationDefs().add(piiTrait); + createType(typesDef); + + try { + entitiesClientV2.deleteClassification(guid, traitName); + fail("Deletion should've failed for non-existent trait association"); + } catch (AtlasServiceException ex) { + Assert.assertNotNull(ex.getStatus()); + assertEquals(ex.getStatus(), ClientResponse.Status.NOT_FOUND); + } + } + + private String random() { + return RandomStringUtils.random(10); + } + + @Test + public void testUTF8() throws Exception { + String classType = random(); + String attrName = random(); + String attrValue = random(); + + AtlasEntityDef classTypeDef = AtlasTypeUtil + .createClassTypeDef(classType, ImmutableSet.<String>of(), + AtlasTypeUtil.createUniqueRequiredAttrDef(attrName, "string")); + AtlasTypesDef atlasTypesDef = new AtlasTypesDef(); + atlasTypesDef.getEntityDefs().add(classTypeDef); + createType(atlasTypesDef); + + AtlasEntity instance = new AtlasEntity(classType); + instance.setAttribute(attrName, attrValue); + AtlasEntityHeader entity = createEntity(instance); + assertNotNull(entity); + assertNotNull(entity.getGuid()); + + AtlasEntity entityByGuid = entitiesClientV2.getEntityByGuid(entity.getGuid()); + assertEquals(entityByGuid.getAttribute(attrName), attrValue); + } + + @Test(dependsOnMethods = "testSubmitEntity") + public void testPartialUpdate() throws Exception { + final List<AtlasEntity> columns = new ArrayList<>(); + Map<String, Object> values = new HashMap<>(); + values.put("name", "col1"); + values.put(QUALIFIED_NAME, "qualifiedName.col1"); + values.put("type", "string"); + values.put("comment", "col1 comment"); + + AtlasEntity ref = new AtlasEntity(BaseResourceIT.COLUMN_TYPE, values); + columns.add(ref); + + AtlasEntityWithAssociations tableUpdated = tableEntity; + tableEntity.setAttribute("columns", columns); + + LOG.debug("Updating entity= " + tableUpdated); + EntityMutationResponse updateResult = entitiesClientV2.updateEntity(tableEntity.getGuid(), tableUpdated); + assertNotNull(updateResult); + assertNotNull(updateResult.getEntitiesByOperation(EntityMutations.EntityOperation.CREATE_OR_UPDATE)); + assertTrue(updateResult.getEntitiesByOperation(EntityMutations.EntityOperation.CREATE_OR_UPDATE).size() > 0); + + AtlasEntity entityByGuid = entitiesClientV2.getEntityByGuid(tableEntity.getGuid()); + assertNotNull(entityByGuid); + List<AtlasEntity> columns1 = (List<AtlasEntity>) entityByGuid.getAttribute("columns"); + + //Update by unique attribute + values.put("type", "int"); + ref = new AtlasEntity(BaseResourceIT.COLUMN_TYPE, values); + columns.set(0, ref); + tableUpdated = tableEntity; + tableUpdated.setAttribute("columns", columns); + + LOG.debug("Updating entity= " + tableUpdated); + EntityMutationResponse updateResponse = entitiesClientV2.updateEntityByAttribute(BaseResourceIT.HIVE_TABLE_TYPE, AtlasClient.REFERENCEABLE_ATTRIBUTE_NAME, + (String) tableEntity.getAttribute("name"), tableUpdated); + assertNotNull(updateResponse); + assertNotNull(updateResponse.getEntitiesByOperation(EntityMutations.EntityOperation.CREATE_OR_UPDATE)); + assertTrue(updateResponse.getEntitiesByOperation(EntityMutations.EntityOperation.CREATE_OR_UPDATE).size() > 0); + + entityByGuid = entitiesClientV2.getEntityByGuid(tableEntity.getGuid()); + assertNotNull(entityByGuid); + columns1 = (List<AtlasEntity>) entityByGuid.getAttribute("columns"); + } + + @Test(dependsOnMethods = "testSubmitEntity") + public void testCompleteUpdate() throws Exception { + final List<AtlasEntity> columns = new ArrayList<>(); + Map<String, Object> values1 = new HashMap<>(); + values1.put("name", "col3"); + values1.put(QUALIFIED_NAME, "qualifiedName.col3"); + values1.put("type", "string"); + values1.put("comment", "col3 comment"); + + Map<String, Object> values2 = new HashMap<>(); + values2.put("name", "col4"); + values2.put(QUALIFIED_NAME, "qualifiedName.col4"); + values2.put("type", "string"); + values2.put("comment", "col4 comment"); + + AtlasEntity ref1 = new AtlasEntity(BaseResourceIT.COLUMN_TYPE, values1); + AtlasEntity ref2 = new AtlasEntity(BaseResourceIT.COLUMN_TYPE, values2); + columns.add(ref1); + columns.add(ref2); + tableEntity.setAttribute("columns", columns); + EntityMutationResponse updateEntityResult = entitiesClientV2.updateEntity(tableEntity); + assertNotNull(updateEntityResult); + assertNotNull(updateEntityResult.getEntitiesByOperation(EntityMutations.EntityOperation.CREATE_OR_UPDATE)); + assertEquals(updateEntityResult.getEntitiesByOperation(EntityMutations.EntityOperation.CREATE_OR_UPDATE).size(), 3); + + AtlasEntity entityByGuid = entitiesClientV2.getEntityByGuid(tableEntity.getGuid()); + List<AtlasEntity> refs = (List<AtlasEntity>) entityByGuid.getAttribute("columns"); + assertEquals(refs.size(), 2); + } + + @Test + public void testDeleteEntities() throws Exception { + // Create 2 database entities + AtlasEntity db1 = new AtlasEntity(DATABASE_TYPE); + String dbName1 = randomString(); + db1.setAttribute("name", dbName1); + db1.setAttribute(QUALIFIED_NAME, dbName1); + db1.setAttribute("clusterName", randomString()); + db1.setAttribute("description", randomString()); + AtlasEntityHeader entity1Header = createEntity(db1); + AtlasEntity db2 = new AtlasEntity(DATABASE_TYPE); + String dbName2 = randomString(); + db2.setAttribute("name", dbName2); + db2.setAttribute(QUALIFIED_NAME, dbName2); + db2.setAttribute("clusterName", randomString()); + db2.setAttribute("description", randomString()); + AtlasEntityHeader entity2Header = createEntity(db2); + + // Delete the database entities + EntityMutationResponse deleteResponse = entitiesClientV2.deleteEntityByGuid(ImmutableList.of(entity1Header.getGuid(), entity2Header.getGuid())); + + // Verify that deleteEntities() response has database entity guids + assertNotNull(deleteResponse); + assertNotNull(deleteResponse.getEntitiesByOperation(EntityMutations.EntityOperation.DELETE)); + assertEquals(deleteResponse.getEntitiesByOperation(EntityMutations.EntityOperation.DELETE).size(), 2); + + // Verify entities were deleted from the repository. + } + + @Test + public void testDeleteEntityByUniqAttribute() throws Exception { + // Create database entity + AtlasEntity hiveDB = createHiveDB(DATABASE_NAME + random()); + String qualifiedName = (String) hiveDB.getAttribute(QUALIFIED_NAME); + + // Delete the database entity + EntityMutationResponse deleteResponse = entitiesClientV2.deleteEntityByAttribute(DATABASE_TYPE, QUALIFIED_NAME, qualifiedName); + + // Verify that deleteEntities() response has database entity guids + assertNotNull(deleteResponse); + assertNotNull(deleteResponse.getEntitiesByOperation(EntityMutations.EntityOperation.DELETE)); + assertEquals(deleteResponse.getEntitiesByOperation(EntityMutations.EntityOperation.DELETE).size(), 1); + + // Verify entities were deleted from the repository. + } + +} http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/ec1b160a/webapp/src/test/java/org/apache/atlas/web/resources/MetadataDiscoveryJerseyResourceIT.java ---------------------------------------------------------------------- diff --git a/webapp/src/test/java/org/apache/atlas/web/resources/MetadataDiscoveryJerseyResourceIT.java b/webapp/src/test/java/org/apache/atlas/web/resources/MetadataDiscoveryJerseyResourceIT.java index ed37c3a..b004cb5 100755 --- a/webapp/src/test/java/org/apache/atlas/web/resources/MetadataDiscoveryJerseyResourceIT.java +++ b/webapp/src/test/java/org/apache/atlas/web/resources/MetadataDiscoveryJerseyResourceIT.java @@ -22,7 +22,6 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import com.sun.jersey.api.client.ClientResponse; import com.sun.jersey.core.util.MultivaluedMapImpl; -import org.apache.atlas.AtlasBaseClient; import org.apache.atlas.AtlasClient; import org.apache.atlas.AtlasServiceException; import org.apache.atlas.typesystem.Referenceable; @@ -43,7 +42,6 @@ import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; import javax.ws.rs.core.MultivaluedMap; -import javax.ws.rs.core.Response; import java.util.List; import static org.testng.Assert.assertEquals; @@ -55,10 +53,6 @@ import static org.testng.Assert.fail; */ public class MetadataDiscoveryJerseyResourceIT extends BaseResourceIT { - private static final String SEARCH_DSL_PATH = "api/atlas/discovery/search/dsl"; - - private static final AtlasBaseClient.APIInfo SEARCH_DSL = new AtlasBaseClient.APIInfo(SEARCH_DSL_PATH, "GET", Response.Status.OK); - public static final String GREMLIN_SEARCH = "api/atlas/discovery/search/gremlin"; private String tagName; private String dbName; @@ -66,8 +60,8 @@ public class MetadataDiscoveryJerseyResourceIT extends BaseResourceIT { public void setUp() throws Exception { super.setUp(); dbName = "db"+randomString(); - - createInstance( createHiveDBInstance(dbName) ); + createTypes(); + createInstance( createHiveDBInstanceV1(dbName) ); } @Test @@ -75,7 +69,7 @@ public class MetadataDiscoveryJerseyResourceIT extends BaseResourceIT { String dslQuery = "from "+ DATABASE_TYPE + " qualifiedName=\"" + dbName + "\""; MultivaluedMap<String, String> queryParams = new MultivaluedMapImpl(); queryParams.add("query", dslQuery); - JSONObject response = serviceClient.callAPIWithQueryParams(AtlasClient.API.SEARCH_DSL, queryParams); + JSONObject response = atlasClientV1.callAPIWithQueryParams(AtlasClient.API.SEARCH_DSL, queryParams); Assert.assertNotNull(response); Assert.assertNotNull(response.get(AtlasClient.REQUEST_ID)); @@ -84,7 +78,7 @@ public class MetadataDiscoveryJerseyResourceIT extends BaseResourceIT { assertEquals(response.getString("queryType"), "dsl"); JSONArray results = response.getJSONArray(AtlasClient.RESULTS); - Assert.assertNotNull(results); + assertNotNull(results); assertEquals(results.length(), 1); int numRows = response.getInt(AtlasClient.COUNT); @@ -98,28 +92,28 @@ public class MetadataDiscoveryJerseyResourceIT extends BaseResourceIT { String dslQuery = "from "+ DATABASE_TYPE + " qualifiedName=\"" + dbName + "\""; MultivaluedMap<String, String> queryParams = new MultivaluedMapImpl(); queryParams.add("query", dslQuery); - JSONObject response = serviceClient.callAPIWithQueryParams(AtlasClient.API.SEARCH_DSL, queryParams); + JSONObject response = atlasClientV1.callAPIWithQueryParams(AtlasClient.API.SEARCH_DSL, queryParams); assertNotNull(response); //higher limit, all results returned - JSONArray results = serviceClient.searchByDSL(dslQuery, 10, 0); + JSONArray results = atlasClientV1.searchByDSL(dslQuery, 10, 0); assertEquals(results.length(), 1); //default limit and offset -1, all results returned - results = serviceClient.searchByDSL(dslQuery, -1, -1); + results = atlasClientV1.searchByDSL(dslQuery, -1, -1); assertEquals(results.length(), 1); //uses the limit parameter passed - results = serviceClient.searchByDSL(dslQuery, 1, 0); + results = atlasClientV1.searchByDSL(dslQuery, 1, 0); assertEquals(results.length(), 1); //uses the offset parameter passed - results = serviceClient.searchByDSL(dslQuery, 10, 1); + results = atlasClientV1.searchByDSL(dslQuery, 10, 1); assertEquals(results.length(), 0); //limit > 0 try { - serviceClient.searchByDSL(dslQuery, 0, 10); + atlasClientV1.searchByDSL(dslQuery, 0, 10); fail("Expected BAD_REQUEST"); } catch (AtlasServiceException e) { assertEquals(e.getStatus(), ClientResponse.Status.BAD_REQUEST, "Got " + e.getStatus()); @@ -127,7 +121,7 @@ public class MetadataDiscoveryJerseyResourceIT extends BaseResourceIT { //limit > maxlimit try { - serviceClient.searchByDSL(dslQuery, Integer.MAX_VALUE, 10); + atlasClientV1.searchByDSL(dslQuery, Integer.MAX_VALUE, 10); fail("Expected BAD_REQUEST"); } catch (AtlasServiceException e) { assertEquals(e.getStatus(), ClientResponse.Status.BAD_REQUEST, "Got " + e.getStatus()); @@ -135,7 +129,7 @@ public class MetadataDiscoveryJerseyResourceIT extends BaseResourceIT { //offset >= 0 try { - serviceClient.searchByDSL(dslQuery, 10, -2); + atlasClientV1.searchByDSL(dslQuery, 10, -2); fail("Expected BAD_REQUEST"); } catch (AtlasServiceException e) { assertEquals(e.getStatus(), ClientResponse.Status.BAD_REQUEST, "Got " + e.getStatus()); @@ -147,8 +141,7 @@ public class MetadataDiscoveryJerseyResourceIT extends BaseResourceIT { String dslQuery = "from blah"; MultivaluedMap<String, String> queryParams = new MultivaluedMapImpl(); queryParams.add("query", dslQuery); - JSONObject response = serviceClient.callAPIWithQueryParams(AtlasClient.API.SEARCH_DSL, queryParams); - + atlasClientV1.callAPIWithQueryParams(AtlasClient.API.SEARCH_DSL, queryParams); } @Test @@ -157,10 +150,10 @@ public class MetadataDiscoveryJerseyResourceIT extends BaseResourceIT { MultivaluedMap<String, String> queryParams = new MultivaluedMapImpl(); queryParams.add("query", query); - JSONObject response = serviceClient.callAPIWithQueryParams(AtlasClient.API.GREMLIN_SEARCH, queryParams); + JSONObject response = atlasClientV1.callAPIWithQueryParams(AtlasClient.API.GREMLIN_SEARCH, queryParams); assertNotNull(response); - Assert.assertNotNull(response.get(AtlasClient.REQUEST_ID)); + assertNotNull(response.get(AtlasClient.REQUEST_ID)); assertEquals(response.getString("query"), query); assertEquals(response.getString("queryType"), "gremlin"); @@ -172,7 +165,7 @@ public class MetadataDiscoveryJerseyResourceIT extends BaseResourceIT { String query = "from "+ DATABASE_TYPE + " qualifiedName=\"" + dbName +"\""; MultivaluedMap<String, String> queryParams = new MultivaluedMapImpl(); queryParams.add("query", query); - JSONObject response = serviceClient.callAPIWithQueryParams(AtlasClient.API.SEARCH, queryParams); + JSONObject response = atlasClientV1.callAPIWithQueryParams(AtlasClient.API.SEARCH, queryParams); Assert.assertNotNull(response); Assert.assertNotNull(response.get(AtlasClient.REQUEST_ID)); @@ -186,7 +179,7 @@ public class MetadataDiscoveryJerseyResourceIT extends BaseResourceIT { String query = "*"; MultivaluedMap<String, String> queryParams = new MultivaluedMapImpl(); queryParams.add("query", query); - JSONObject response = serviceClient.callAPIWithQueryParams(AtlasClient.API.SEARCH, queryParams); + JSONObject response = atlasClientV1.callAPIWithQueryParams(AtlasClient.API.SEARCH, queryParams); Assert.assertNotNull(response); Assert.assertNotNull(response.get(AtlasClient.REQUEST_ID)); @@ -197,8 +190,8 @@ public class MetadataDiscoveryJerseyResourceIT extends BaseResourceIT { @Test(dependsOnMethods = "testSearchDSLLimits") public void testSearchUsingFullText() throws Exception { - JSONObject response = serviceClient.searchByFullText(dbName, 10, 0); - Assert.assertNotNull(response.get(AtlasClient.REQUEST_ID)); + JSONObject response = atlasClientV1.searchByFullText(dbName, 10, 0); + assertNotNull(response.get(AtlasClient.REQUEST_ID)); assertEquals(response.getString("query"), dbName); assertEquals(response.getString("queryType"), "full-text"); @@ -207,9 +200,9 @@ public class MetadataDiscoveryJerseyResourceIT extends BaseResourceIT { assertEquals(results.length(), 1, "Results: " + results); JSONObject row = results.getJSONObject(0); - Assert.assertNotNull(row.get("guid")); + assertNotNull(row.get("guid")); assertEquals(row.getString("typeName"), DATABASE_TYPE); - Assert.assertNotNull(row.get("score")); + assertNotNull(row.get("score")); int numRows = response.getInt(AtlasClient.COUNT); assertEquals(numRows, 1); @@ -218,25 +211,25 @@ public class MetadataDiscoveryJerseyResourceIT extends BaseResourceIT { String query = dbName; MultivaluedMap<String, String> queryParams = new MultivaluedMapImpl(); queryParams.add("query", query); - response = serviceClient.callAPIWithQueryParams(AtlasClient.API.SEARCH_FULL_TEXT, queryParams); + response = atlasClientV1.callAPIWithQueryParams(AtlasClient.API.SEARCH_FULL_TEXT, queryParams); results = response.getJSONArray(AtlasClient.RESULTS); assertEquals(results.length(), 1); //verify passed in limits and offsets are used //higher limit and 0 offset returns all results - results = serviceClient.searchByFullText(query, 10, 0).getJSONArray(AtlasClient.RESULTS); + results = atlasClientV1.searchByFullText(query, 10, 0).getJSONArray(AtlasClient.RESULTS); assertEquals(results.length(), 1); //offset is used - results = serviceClient.searchByFullText(query, 10, 1).getJSONArray(AtlasClient.RESULTS); + results = atlasClientV1.searchByFullText(query, 10, 1).getJSONArray(AtlasClient.RESULTS); assertEquals(results.length(), 0); //limit is used - results = serviceClient.searchByFullText(query, 1, 0).getJSONArray(AtlasClient.RESULTS); + results = atlasClientV1.searchByFullText(query, 1, 0).getJSONArray(AtlasClient.RESULTS); assertEquals(results.length(), 1); //higher offset returns 0 results - results = serviceClient.searchByFullText(query, 1, 2).getJSONArray(AtlasClient.RESULTS); + results = atlasClientV1.searchByFullText(query, 1, 2).getJSONArray(AtlasClient.RESULTS); assertEquals(results.length(), 0); } http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/ec1b160a/webapp/src/test/java/org/apache/atlas/web/resources/TypesJerseyResourceIT.java ---------------------------------------------------------------------- diff --git a/webapp/src/test/java/org/apache/atlas/web/resources/TypesJerseyResourceIT.java b/webapp/src/test/java/org/apache/atlas/web/resources/TypesJerseyResourceIT.java index 87bf9a8..2ef33c3 100755 --- a/webapp/src/test/java/org/apache/atlas/web/resources/TypesJerseyResourceIT.java +++ b/webapp/src/test/java/org/apache/atlas/web/resources/TypesJerseyResourceIT.java @@ -76,33 +76,33 @@ public class TypesJerseyResourceIT extends BaseResourceIT { public void testSubmit() throws Exception { for (HierarchicalTypeDefinition typeDefinition : typeDefinitions) { try{ - serviceClient.getType(typeDefinition.typeName); + atlasClientV1.getType(typeDefinition.typeName); } catch (AtlasServiceException ase){ String typesAsJSON = TypesSerialization.toJson(typeDefinition, false); System.out.println("typesAsJSON = " + typesAsJSON); - JSONObject response = serviceClient.callAPIWithBody(AtlasClient.API.CREATE_TYPE, typesAsJSON); - Assert.assertNotNull(response); + JSONObject response = atlasClientV1.callAPIWithBody(AtlasClient.API.CREATE_TYPE, typesAsJSON); + Assert.assertNotNull(response); - JSONArray typesAdded = response.getJSONArray(AtlasClient.TYPES); - assertEquals(typesAdded.length(), 1); - assertEquals(typesAdded.getJSONObject(0).getString("name"), typeDefinition.typeName); - Assert.assertNotNull(response.get(AtlasClient.REQUEST_ID));} + JSONArray typesAdded = response.getJSONArray(AtlasClient.TYPES); + assertEquals(typesAdded.length(), 1); + assertEquals(typesAdded.getJSONObject(0).getString(NAME), typeDefinition.typeName); + Assert.assertNotNull(response.get(AtlasClient.REQUEST_ID));} } } @Test public void testDuplicateSubmit() throws Exception { HierarchicalTypeDefinition<ClassType> type = TypesUtil.createClassTypeDef(randomString(), - ImmutableSet.<String>of(), TypesUtil.createUniqueRequiredAttrDef("name", DataTypes.STRING_TYPE)); + ImmutableSet.<String>of(), TypesUtil.createUniqueRequiredAttrDef(NAME, DataTypes.STRING_TYPE)); TypesDef typesDef = TypesUtil.getTypesDef(ImmutableList.<EnumTypeDefinition>of(), ImmutableList.<StructTypeDefinition>of(), ImmutableList.<HierarchicalTypeDefinition<TraitType>>of(), ImmutableList.of(type)); - serviceClient.createType(typesDef); + atlasClientV1.createType(typesDef); try { - serviceClient.createType(typesDef); + atlasClientV1.createType(typesDef); fail("Expected 409"); } catch (AtlasServiceException e) { assertEquals(e.getStatus().getStatusCode(), Response.Status.CONFLICT.getStatusCode()); @@ -113,24 +113,24 @@ public class TypesJerseyResourceIT extends BaseResourceIT { public void testUpdate() throws Exception { HierarchicalTypeDefinition<ClassType> typeDefinition = TypesUtil .createClassTypeDef(randomString(), ImmutableSet.<String>of(), - TypesUtil.createUniqueRequiredAttrDef("name", DataTypes.STRING_TYPE)); - List<String> typesCreated = serviceClient.createType(TypesSerialization.toJson(typeDefinition, false)); + TypesUtil.createUniqueRequiredAttrDef(NAME, DataTypes.STRING_TYPE)); + List<String> typesCreated = atlasClientV1.createType(TypesSerialization.toJson(typeDefinition, false)); assertEquals(typesCreated.size(), 1); assertEquals(typesCreated.get(0), typeDefinition.typeName); //Add attribute description typeDefinition = TypesUtil.createClassTypeDef(typeDefinition.typeName, - ImmutableSet.<String>of(), - TypesUtil.createUniqueRequiredAttrDef("name", DataTypes.STRING_TYPE), - createOptionalAttrDef("description", DataTypes.STRING_TYPE)); + ImmutableSet.<String>of(), + TypesUtil.createUniqueRequiredAttrDef(NAME, DataTypes.STRING_TYPE), + createOptionalAttrDef(DESCRIPTION, DataTypes.STRING_TYPE)); TypesDef typeDef = TypesUtil.getTypesDef(ImmutableList.<EnumTypeDefinition>of(), ImmutableList.<StructTypeDefinition>of(), ImmutableList.<HierarchicalTypeDefinition<TraitType>>of(), ImmutableList.of(typeDefinition)); - List<String> typesUpdated = serviceClient.updateType(typeDef); + List<String> typesUpdated = atlasClientV1.updateType(typeDef); assertEquals(typesUpdated.size(), 1); Assert.assertTrue(typesUpdated.contains(typeDefinition.typeName)); - TypesDef updatedTypeDef = serviceClient.getType(typeDefinition.typeName); + TypesDef updatedTypeDef = atlasClientV1.getType(typeDefinition.typeName); assertNotNull(updatedTypeDef); HierarchicalTypeDefinition<ClassType> updatedType = updatedTypeDef.classTypesAsJavaList().get(0); @@ -142,7 +142,7 @@ public class TypesJerseyResourceIT extends BaseResourceIT { for (HierarchicalTypeDefinition typeDefinition : typeDefinitions) { System.out.println("typeName = " + typeDefinition.typeName); - JSONObject response = serviceClient.callAPIWithBodyAndParams(AtlasClient.API.LIST_TYPES, null, typeDefinition.typeName); + JSONObject response = atlasClientV1.callAPIWithBodyAndParams(AtlasClient.API.LIST_TYPES, null, typeDefinition.typeName); Assert.assertNotNull(response); Assert.assertNotNull(response.get(AtlasClient.DEFINITION)); @@ -153,7 +153,7 @@ public class TypesJerseyResourceIT extends BaseResourceIT { List<HierarchicalTypeDefinition<ClassType>> hierarchicalTypeDefinitions = typesDef.classTypesAsJavaList(); for (HierarchicalTypeDefinition<ClassType> classType : hierarchicalTypeDefinitions) { for (AttributeDefinition attrDef : classType.attributeDefinitions) { - if ("name".equals(attrDef.name)) { + if (NAME.equals(attrDef.name)) { assertEquals(attrDef.isIndexable, true); assertEquals(attrDef.isUnique, true); } @@ -164,12 +164,12 @@ public class TypesJerseyResourceIT extends BaseResourceIT { @Test(expectedExceptions = AtlasServiceException.class) public void testGetDefinitionForNonexistentType() throws Exception { - JSONObject response = serviceClient.callAPIWithBodyAndParams(AtlasClient.API.LIST_TYPES, null, "blah"); + JSONObject response = atlasClientV1.callAPIWithBodyAndParams(AtlasClient.API.LIST_TYPES, null, "blah"); } @Test(dependsOnMethods = "testSubmit") public void testGetTypeNames() throws Exception { - JSONObject response = serviceClient.callAPIWithBodyAndParams(AtlasClient.API.LIST_TYPES, null, (String[]) null); + JSONObject response = atlasClientV1.callAPIWithBodyAndParams(AtlasClient.API.LIST_TYPES, null, (String[]) null); Assert.assertNotNull(response); Assert.assertNotNull(response.get(AtlasClient.REQUEST_ID)); @@ -190,7 +190,7 @@ public class TypesJerseyResourceIT extends BaseResourceIT { MultivaluedMap<String, String> queryParams = new MultivaluedMapImpl(); queryParams.add("type", DataTypes.TypeCategory.TRAIT.name()); - JSONObject response = serviceClient.callAPIWithQueryParams(AtlasClient.API.LIST_TYPES, queryParams); + JSONObject response = atlasClientV1.callAPIWithQueryParams(AtlasClient.API.LIST_TYPES, queryParams); Assert.assertNotNull(response); Assert.assertNotNull(response.get(AtlasClient.REQUEST_ID)); @@ -212,7 +212,7 @@ public class TypesJerseyResourceIT extends BaseResourceIT { String c = createType(TypesSerialization.toJson( TypesUtil.createClassTypeDef("C" + randomString(), ImmutableSet.of(a, b), attr), false)).get(0); - List<String> results = serviceClient.listTypes(DataTypes.TypeCategory.CLASS, a, b); + List<String> results = atlasClientV1.listTypes(DataTypes.TypeCategory.CLASS, a, b); assertEquals(results, Arrays.asList(a1), "Results: " + results); } @@ -234,20 +234,20 @@ public class TypesJerseyResourceIT extends BaseResourceIT { HierarchicalTypeDefinition<ClassType> databaseTypeDefinition = TypesUtil .createClassTypeDef("database", ImmutableSet.<String>of(), - TypesUtil.createUniqueRequiredAttrDef("name", DataTypes.STRING_TYPE), - TypesUtil.createRequiredAttrDef("description", DataTypes.STRING_TYPE), - TypesUtil.createRequiredAttrDef("qualifiedName", DataTypes.STRING_TYPE)); + TypesUtil.createUniqueRequiredAttrDef(NAME, DataTypes.STRING_TYPE), + TypesUtil.createRequiredAttrDef(DESCRIPTION, DataTypes.STRING_TYPE), + TypesUtil.createRequiredAttrDef(QUALIFIED_NAME, DataTypes.STRING_TYPE)); typeDefinitions.add(databaseTypeDefinition); HierarchicalTypeDefinition<ClassType> tableTypeDefinition = TypesUtil .createClassTypeDef("table", ImmutableSet.<String>of(), - TypesUtil.createUniqueRequiredAttrDef("name", DataTypes.STRING_TYPE), - TypesUtil.createRequiredAttrDef("description", DataTypes.STRING_TYPE), - TypesUtil.createRequiredAttrDef("qualifiedName", DataTypes.STRING_TYPE), + TypesUtil.createUniqueRequiredAttrDef(NAME, DataTypes.STRING_TYPE), + TypesUtil.createRequiredAttrDef(DESCRIPTION, DataTypes.STRING_TYPE), + TypesUtil.createRequiredAttrDef(QUALIFIED_NAME, DataTypes.STRING_TYPE), createOptionalAttrDef("columnNames", DataTypes.arrayTypeName(DataTypes.STRING_TYPE)), createOptionalAttrDef("created", DataTypes.DATE_TYPE), createOptionalAttrDef("parameters", - DataTypes.mapTypeName(DataTypes.STRING_TYPE, DataTypes.STRING_TYPE)), + DataTypes.mapTypeName(DataTypes.STRING_TYPE, DataTypes.STRING_TYPE)), TypesUtil.createRequiredAttrDef("type", DataTypes.STRING_TYPE), new AttributeDefinition("database", "database", Multiplicity.REQUIRED, false, "database")); typeDefinitions.add(tableTypeDefinition);
