@Test
  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));
    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));
    TypesDef typeDef =
        TypesUtil.getTypesDef(
            ImmutableList.<EnumTypeDefinition>of(),
            ImmutableList.<StructTypeDefinition>of(),
            ImmutableList.<HierarchicalTypeDefinition<TraitType>>of(),
            ImmutableList.of(typeDefinition));
    List<String> typesUpdated = serviceClient.updateType(typeDef);
    assertEquals(typesUpdated.size(), 1);
    Assert.assertTrue(typesUpdated.contains(typeDefinition.typeName));

    HierarchicalTypeDefinition<ClassType> updatedType =
        serviceClient.getType(typeDefinition.typeName).classTypesAsJavaList().get(0);
    assertEquals(updatedType.attributeDefinitions.length, 2);
  }
  private List<HierarchicalTypeDefinition> createHiveTypes() throws Exception {
    ArrayList<HierarchicalTypeDefinition> typeDefinitions = new ArrayList<>();

    HierarchicalTypeDefinition<ClassType> databaseTypeDefinition =
        TypesUtil.createClassTypeDef(
            "database",
            ImmutableSet.<String>of(),
            TypesUtil.createUniqueRequiredAttrDef("name", DataTypes.STRING_TYPE),
            TypesUtil.createRequiredAttrDef("description", 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),
            createOptionalAttrDef("columnNames", DataTypes.arrayTypeName(DataTypes.STRING_TYPE)),
            createOptionalAttrDef("created", DataTypes.DATE_TYPE),
            createOptionalAttrDef(
                "parameters", 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);

    HierarchicalTypeDefinition<TraitType> fetlTypeDefinition =
        TypesUtil.createTraitTypeDef(
            "fetl",
            ImmutableSet.<String>of(),
            TypesUtil.createRequiredAttrDef("level", DataTypes.INT_TYPE));
    typeDefinitions.add(fetlTypeDefinition);

    return typeDefinitions;
  }
  @Test
  public void testUTF8() throws Exception {
    String classType = random();
    String attrName = random();
    String attrValue = random();

    HierarchicalTypeDefinition<ClassType> classTypeDefinition =
        TypesUtil.createClassTypeDef(
            classType,
            ImmutableList.<String>of(),
            TypesUtil.createUniqueRequiredAttrDef(attrName, DataTypes.STRING_TYPE));
    TypesDef typesDef =
        TypeUtils.getTypesDef(
            ImmutableList.<EnumTypeDefinition>of(),
            ImmutableList.<StructTypeDefinition>of(),
            ImmutableList.<HierarchicalTypeDefinition<TraitType>>of(),
            ImmutableList.of(classTypeDefinition));
    createType(typesDef);

    Referenceable instance = new Referenceable(classType);
    instance.set(attrName, attrValue);
    Id guid = createInstance(instance);

    ClientResponse response = getEntityDefinition(guid._getId());
    String definition = getEntityDefinition(response);
    Referenceable getReferenceable = InstanceSerialization.fromJsonReferenceable(definition, true);
    Assert.assertEquals(getReferenceable.get(attrName), attrValue);
  }
  @Test
  public void testDuplicateSubmit() throws Exception {
    HierarchicalTypeDefinition<ClassType> type =
        TypesUtil.createClassTypeDef(
            randomString(),
            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);

    try {
      serviceClient.createType(typesDef);
      fail("Expected 409");
    } catch (AtlasServiceException e) {
      assertEquals(e.getStatus().getStatusCode(), Response.Status.CONFLICT.getStatusCode());
    }
  }