ATLAS-2534: Glossary REST API (bugfix)

intg/src/main/java/org/apache/atlas/AtlasErrorCode.java

@@ -168,6 +168,9 @@ public enum AtlasErrorCode {
     RELATIONSHIP_ALREADY_EXISTS(409, "ATLAS-409-00-004", "relationship {0} already exists between entities {1} and {2}"),
     TYPE_HAS_RELATIONSHIPS(409, "ATLAS-409-00-005", "Given type {0} has associated relationshipDefs"),
     SAVED_SEARCH_ALREADY_EXISTS(409, "ATLAS-409-00-006", "search named {0} already exists for user {1}"),
+    GLOSSARY_ALREADY_EXISTS(409, "ATLAS-409-00-007", "Glossary with qualifiedName {0} already exists"),
+    GLOSSARY_TERM_ALREADY_EXISTS(409, "ATLAS-409-00-009", "Glossary term with qualifiedName {0} already exists"),
+    GLOSSARY_CATEGORY_ALREADY_EXISTS(409, "ATLAS-409-00-00A", "Glossary category with qualifiedName {0} already exists"),
 
     // All internal errors go here
     INTERNAL_ERROR(500, "ATLAS-500-00-001", "Internal server error {0}"),

repository/src/main/java/org/apache/atlas/glossary/GlossaryCategoryUtils.java

@@ -29,9 +29,13 @@ import org.apache.atlas.repository.store.graph.AtlasRelationshipStore;
 import org.apache.atlas.type.AtlasRelationshipType;
 import org.apache.atlas.type.AtlasTypeRegistry;
 import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.collections.MapUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -96,8 +100,8 @@ public class GlossaryCategoryUtils extends GlossaryUtils {
         }
     }
 
-    private void processParentCategory(AtlasGlossaryCategory newObj, AtlasGlossaryCategory existing, RelationshipOperation op) throws AtlasBaseException {
-        AtlasRelatedCategoryHeader newParent      = newObj.getParentCategory();
+    private void processParentCategory(AtlasGlossaryCategory updatedCategory, AtlasGlossaryCategory existing, RelationshipOperation op) throws AtlasBaseException {
+        AtlasRelatedCategoryHeader newParent      = updatedCategory.getParentCategory();
         AtlasRelatedCategoryHeader existingParent = existing.getParentCategory();
         switch (op) {
             case CREATE:
@@ -152,9 +156,9 @@ public class GlossaryCategoryUtils extends GlossaryUtils {
         }
     }
 
-    private void processAssociatedTerms(AtlasGlossaryCategory newObj, AtlasGlossaryCategory existing, RelationshipOperation op) throws AtlasBaseException {
-        Set<AtlasRelatedTermHeader> newTerms      = newObj.getTerms();
-        Set<AtlasRelatedTermHeader> existingTerms = existing.getTerms();
+    private void processAssociatedTerms(AtlasGlossaryCategory updatedCategory, AtlasGlossaryCategory existing, RelationshipOperation op) throws AtlasBaseException {
+        Map<String, AtlasRelatedTermHeader> newTerms      = getTerms(updatedCategory);
+        Map<String, AtlasRelatedTermHeader> existingTerms = getTerms(existing);
 
         switch (op) {
             case CREATE:
@@ -162,51 +166,66 @@ public class GlossaryCategoryUtils extends GlossaryUtils {
                     LOG.debug("Creating term relation with category = {}, terms = {}", existing.getDisplayName(),
                               Objects.nonNull(newTerms) ? newTerms.size() : "none");
                 }
-                createTermCategorizationRelationships(existing, newTerms);
+                createTermCategorizationRelationships(existing, newTerms.values());
                 break;
             case UPDATE:
-                if (CollectionUtils.isEmpty(existingTerms)) {
+                if (MapUtils.isEmpty(existingTerms)) {
                     if (DEBUG_ENABLED) {
                         LOG.debug("Creating term relation with category = {}, terms = {}", existing.getDisplayName(),
                                   Objects.nonNull(newTerms) ? newTerms.size() : "none");
                     }
-                    createTermCategorizationRelationships(existing, newTerms);
+                    createTermCategorizationRelationships(existing, newTerms.values());
                     break;
                 }
 
-                if (CollectionUtils.isEmpty(newTerms)) {
+                if (MapUtils.isEmpty(newTerms)) {
                     if (DEBUG_ENABLED) {
                         LOG.debug("Deleting term relation with category = {}, terms = {}", existing.getDisplayName(), existingTerms.size());
                     }
-                    deleteTermCategorizationRelationships(existing, existingTerms);
+                    deleteTermCategorizationRelationships(existing, existingTerms.values());
                     break;
                 }
 
                 Set<AtlasRelatedTermHeader> toCreate = newTerms
+                                                               .values()
                                                                .stream()
-                                                               .filter(c -> Objects.isNull(c.getRelationGuid()))
+                                                               .filter(t -> !existingTerms.containsKey(t.getTermGuid()))
                                                                .collect(Collectors.toSet());
                 createTermCategorizationRelationships(existing, toCreate);
 
                 Set<AtlasRelatedTermHeader> toUpdate = newTerms
+                                                               .values()
                                                                .stream()
-                                                               .filter(c -> Objects.nonNull(c.getRelationGuid()) && existingTerms.contains(c))
+                                                               .filter(t -> updatedExistingTermRelation(existingTerms, t))
                                                                .collect(Collectors.toSet());
                 updateTermCategorizationRelationships(existing, toUpdate);
 
                 Set<AtlasRelatedTermHeader> toDelete = existingTerms
+                                                               .values()
                                                                .stream()
-                                                               .filter(c -> !toCreate.contains(c) && !toUpdate.contains(c))
+                                                               .filter(t -> !newTerms.containsKey(t.getTermGuid()))
                                                                .collect(Collectors.toSet());
                 deleteTermCategorizationRelationships(existing, toDelete);
                 break;
             case DELETE:
-                deleteTermCategorizationRelationships(existing, existingTerms);
+                deleteTermCategorizationRelationships(existing, existingTerms.values());
                 break;
         }
     }
 
-    private void createTermCategorizationRelationships(AtlasGlossaryCategory existing, Set<AtlasRelatedTermHeader> terms) throws AtlasBaseException {
+    private boolean updatedExistingTermRelation(Map<String, AtlasRelatedTermHeader> existingTerms, AtlasRelatedTermHeader term) {
+        return Objects.nonNull(term.getRelationGuid()) && !existingTerms.get(term.getTermGuid()).equals(term);
+    }
+
+    private Map<String, AtlasRelatedTermHeader> getTerms(final AtlasGlossaryCategory category) {
+        return Objects.nonNull(category.getTerms()) ?
+                       category.getTerms()
+                               .stream()
+                               .collect(Collectors.toMap(AtlasRelatedTermHeader::getTermGuid, t -> t)) :
+                       Collections.EMPTY_MAP;
+    }
+
+    private void createTermCategorizationRelationships(AtlasGlossaryCategory existing, Collection<AtlasRelatedTermHeader> terms) throws AtlasBaseException {
         if (CollectionUtils.isNotEmpty(terms)) {
             Set<AtlasRelatedTermHeader> existingTerms = existing.getTerms();
             for (AtlasRelatedTermHeader term : terms) {
@@ -228,7 +247,7 @@ public class GlossaryCategoryUtils extends GlossaryUtils {
         }
     }
 
-    private void updateTermCategorizationRelationships(AtlasGlossaryCategory existing, Set<AtlasRelatedTermHeader> terms) throws AtlasBaseException {
+    private void updateTermCategorizationRelationships(AtlasGlossaryCategory existing, Collection<AtlasRelatedTermHeader> terms) throws AtlasBaseException {
         if (CollectionUtils.isNotEmpty(terms)) {
             for (AtlasRelatedTermHeader term : terms) {
                 if (DEBUG_ENABLED) {
@@ -241,7 +260,7 @@ public class GlossaryCategoryUtils extends GlossaryUtils {
         }
     }
 
-    private void deleteTermCategorizationRelationships(AtlasGlossaryCategory existing, Set<AtlasRelatedTermHeader> terms) throws AtlasBaseException {
+    private void deleteTermCategorizationRelationships(AtlasGlossaryCategory existing, Collection<AtlasRelatedTermHeader> terms) throws AtlasBaseException {
         if (CollectionUtils.isNotEmpty(terms)) {
             for (AtlasRelatedTermHeader term : terms) {
                 if (DEBUG_ENABLED) {
@@ -252,61 +271,76 @@ public class GlossaryCategoryUtils extends GlossaryUtils {
         }
     }
 
-    private void processCategoryChildren(AtlasGlossaryCategory newObj, AtlasGlossaryCategory existing, RelationshipOperation op) throws AtlasBaseException {
-        Set<AtlasRelatedCategoryHeader> newChildren      = newObj.getChildrenCategories();
-        Set<AtlasRelatedCategoryHeader> existingChildren = existing.getChildrenCategories();
+    private void processCategoryChildren(AtlasGlossaryCategory updatedCategory, AtlasGlossaryCategory existing, RelationshipOperation op) throws AtlasBaseException {
+        Map<String, AtlasRelatedCategoryHeader> newChildren      = getChildren(updatedCategory);
+        Map<String, AtlasRelatedCategoryHeader> existingChildren = getChildren(existing);
         switch (op) {
             case CREATE:
                 if (DEBUG_ENABLED) {
                     LOG.debug("Creating new children, category = {}, children = {}", existing.getDisplayName(),
                               Objects.nonNull(newChildren) ? newChildren.size() : "none");
                 }
-                createCategoryRelationships(existing, newChildren);
+                createCategoryRelationships(existing, newChildren.values());
                 break;
             case UPDATE:
                 // Create new children
-                if (CollectionUtils.isEmpty(existingChildren)) {
+                if (MapUtils.isEmpty(existingChildren)) {
                     if (DEBUG_ENABLED) {
                         LOG.debug("Creating new children, category = {}, children = {}", existing.getDisplayName(),
                                   Objects.nonNull(newChildren) ? newChildren.size() : "none");
                     }
-                    createCategoryRelationships(existing, newChildren);
+                    createCategoryRelationships(existing, newChildren.values());
                     break;
                 }
                 // Delete current children
-                if (CollectionUtils.isEmpty(newChildren)) {
+                if (MapUtils.isEmpty(newChildren)) {
                     if (DEBUG_ENABLED) {
                         LOG.debug("Deleting children, category = {}, children = {}", existing.getDisplayName(), existingChildren.size());
                     }
-                    deleteCategoryRelationships(existing, existingChildren);
+                    deleteCategoryRelationships(existing, existingChildren.values());
                     break;
                 }
 
                 Set<AtlasRelatedCategoryHeader> toCreate = newChildren
+                                                                   .values()
                                                                    .stream()
-                                                                   .filter(c -> Objects.isNull(c.getRelationGuid()))
+                                                                   .filter(c -> !existingChildren.containsKey(c.getCategoryGuid()))
                                                                    .collect(Collectors.toSet());
                 createCategoryRelationships(existing, toCreate);
 
                 Set<AtlasRelatedCategoryHeader> toUpdate = newChildren
+                                                                   .values()
                                                                    .stream()
-                                                                   .filter(c -> Objects.nonNull(c.getRelationGuid()) && existingChildren.contains(c))
+                                                                   .filter(c -> updatedExistingCategoryRelation(existingChildren, c))
                                                                    .collect(Collectors.toSet());
                 updateCategoryRelationships(existing, toUpdate);
 
                 Set<AtlasRelatedCategoryHeader> toDelete = existingChildren
+                                                                   .values()
                                                                    .stream()
-                                                                   .filter(c -> !toCreate.contains(c) && !toUpdate.contains(c))
+                                                                   .filter(c -> !newChildren.containsKey(c.getCategoryGuid()))
                                                                    .collect(Collectors.toSet());
                 deleteCategoryRelationships(existing, toDelete);
                 break;
             case DELETE:
-                deleteCategoryRelationships(existing, existingChildren);
+                deleteCategoryRelationships(existing, existingChildren.values());
                 break;
         }
     }
 
-    private void createCategoryRelationships(AtlasGlossaryCategory existing, Set<AtlasRelatedCategoryHeader> newChildren) throws AtlasBaseException {
+    private boolean updatedExistingCategoryRelation(Map<String, AtlasRelatedCategoryHeader> existingChildren, AtlasRelatedCategoryHeader header) {
+        return Objects.nonNull(header.getRelationGuid()) && !header.equals(existingChildren.get(header.getCategoryGuid()));
+    }
+
+    private Map<String, AtlasRelatedCategoryHeader> getChildren(final AtlasGlossaryCategory category) {
+        return Objects.nonNull(category.getChildrenCategories()) ?
+                       category.getChildrenCategories()
+                               .stream()
+                               .collect(Collectors.toMap(AtlasRelatedCategoryHeader::getCategoryGuid, c -> c)) :
+                       Collections.EMPTY_MAP;
+    }
+
+    private void createCategoryRelationships(AtlasGlossaryCategory existing, Collection<AtlasRelatedCategoryHeader> newChildren) throws AtlasBaseException {
         if (CollectionUtils.isNotEmpty(newChildren)) {
             Set<AtlasRelatedCategoryHeader> existingChildren = existing.getChildrenCategories();
             for (AtlasRelatedCategoryHeader child : newChildren) {
@@ -324,7 +358,7 @@ public class GlossaryCategoryUtils extends GlossaryUtils {
         }
     }
 
-    private void updateCategoryRelationships(AtlasGlossaryCategory existing, Set<AtlasRelatedCategoryHeader> toUpdate) throws AtlasBaseException {
+    private void updateCategoryRelationships(AtlasGlossaryCategory existing, Collection<AtlasRelatedCategoryHeader> toUpdate) throws AtlasBaseException {
         if (CollectionUtils.isNotEmpty(toUpdate)) {
             for (AtlasRelatedCategoryHeader categoryHeader : toUpdate) {
                 if (DEBUG_ENABLED) {
@@ -337,7 +371,7 @@ public class GlossaryCategoryUtils extends GlossaryUtils {
         }
     }
 
-    private void deleteCategoryRelationships(AtlasGlossaryCategory existing, Set<AtlasRelatedCategoryHeader> existingChildren) throws AtlasBaseException {
+    private void deleteCategoryRelationships(AtlasGlossaryCategory existing, Collection<AtlasRelatedCategoryHeader> existingChildren) throws AtlasBaseException {
         if (CollectionUtils.isNotEmpty(existingChildren)) {
             for (AtlasRelatedCategoryHeader child : existingChildren) {
                 if (DEBUG_ENABLED) {

repository/src/main/java/org/apache/atlas/glossary/GlossaryService.java

@@ -27,6 +27,7 @@ import org.apache.atlas.model.glossary.relations.AtlasRelatedCategoryHeader;
 import org.apache.atlas.model.glossary.relations.AtlasRelatedTermHeader;
 import org.apache.atlas.model.glossary.relations.AtlasTermCategorizationHeader;
 import org.apache.atlas.model.instance.AtlasRelatedObjectId;
+import org.apache.atlas.repository.graphdb.AtlasVertex;
 import org.apache.atlas.repository.ogm.DataAccess;
 import org.apache.atlas.repository.store.graph.AtlasRelationshipStore;
 import org.apache.atlas.repository.store.graph.v1.AtlasGraphUtilsV1;
@@ -53,13 +54,17 @@ public class GlossaryService {
     private static final Logger  LOG           = LoggerFactory.getLogger(GlossaryService.class);
     private static final boolean DEBUG_ENABLED = LOG.isDebugEnabled();
 
+    private static final String QUALIFIED_NAME_ATTR              = "qualifiedName";
+
     private final DataAccess            dataAccess;
     private final GlossaryTermUtils     glossaryTermUtils;
     private final GlossaryCategoryUtils glossaryCategoryUtils;
+    private final AtlasTypeRegistry     atlasTypeRegistry;
 
     @Inject
     public GlossaryService(DataAccess dataAccess, final AtlasRelationshipStore relationshipStore, final AtlasTypeRegistry typeRegistry) {
         this.dataAccess = dataAccess;
+        this.atlasTypeRegistry = typeRegistry;
         glossaryTermUtils = new GlossaryTermUtils(relationshipStore, typeRegistry);
         glossaryCategoryUtils = new GlossaryCategoryUtils(relationshipStore, typeRegistry);
     }
@@ -78,7 +83,7 @@ public class GlossaryService {
             LOG.debug("==> GlossaryService.getGlossaries({}, {}, {})", limit, offset, sortOrder);
         }
 
-        List<String>     glossaryGuids    = AtlasGraphUtilsV1.findEntityGUIDsByType(GlossaryUtils.ATLAS_GLOSSARY_PREFIX, sortOrder);
+        List<String>     glossaryGuids    = AtlasGraphUtilsV1.findEntityGUIDsByType(GlossaryUtils.ATLAS_GLOSSARY_TYPENAME, sortOrder);
         PaginationHelper paginationHelper = new PaginationHelper<>(glossaryGuids, offset, limit);
 
         List<AtlasGlossary> ret;
@@ -118,6 +123,7 @@ public class GlossaryService {
         if (Objects.isNull(atlasGlossary)) {
             throw new AtlasBaseException(AtlasErrorCode.BAD_REQUEST, "Glossary definition missing");
         }
+
         if (StringUtils.isEmpty(atlasGlossary.getQualifiedName())) {
             if (StringUtils.isEmpty(atlasGlossary.getDisplayName())) {
                 throw new AtlasBaseException(AtlasErrorCode.GLOSSARY_QUALIFIED_NAME_CANT_BE_DERIVED);
@@ -125,11 +131,17 @@ public class GlossaryService {
                 atlasGlossary.setQualifiedName(atlasGlossary.getDisplayName());
             }
         }
+
+        if (glossaryExists(atlasGlossary)) {
+            throw new AtlasBaseException(AtlasErrorCode.GLOSSARY_ALREADY_EXISTS, atlasGlossary.getQualifiedName());
+        }
+
         AtlasGlossary saved = dataAccess.save(atlasGlossary);
 
         if (DEBUG_ENABLED) {
             LOG.debug("<== GlossaryService.createGlossary() : {}", saved);
         }
+
         return saved;
     }
 
@@ -297,6 +309,10 @@ public class GlossaryService {
             }
         }
 
+        if (termExists(glossaryTerm)) {
+            throw new AtlasBaseException(AtlasErrorCode.GLOSSARY_TERM_ALREADY_EXISTS, glossaryTerm.getQualifiedName());
+        }
+
         AtlasGlossaryTerm existing = dataAccess.save(glossaryTerm);
         glossaryTermUtils.processTermRelations(glossaryTerm, existing, GlossaryUtils.RelationshipOperation.CREATE);
 
@@ -457,6 +473,10 @@ public class GlossaryService {
             }
         }
 
+        if (categoryExists(glossaryCategory)) {
+            throw new AtlasBaseException(AtlasErrorCode.GLOSSARY_CATEGORY_ALREADY_EXISTS, glossaryCategory.getQualifiedName());
+        }
+
         AtlasGlossaryCategory saved = dataAccess.save(glossaryCategory);
 
         // Attempt relation creation
@@ -726,6 +746,27 @@ public class GlossaryService {
         return glossary;
     }
 
+    private boolean glossaryExists(AtlasGlossary atlasGlossary) {
+        AtlasVertex vertex = AtlasGraphUtilsV1.findByUniqueAttributes(atlasTypeRegistry.getEntityTypeByName(GlossaryUtils.ATLAS_GLOSSARY_TYPENAME), new HashMap<String, Object>() {{
+            put(QUALIFIED_NAME_ATTR, atlasGlossary.getQualifiedName());
+        }});
+        return Objects.nonNull(vertex);
+    }
+
+    private boolean termExists(AtlasGlossaryTerm term) {
+        AtlasVertex vertex = AtlasGraphUtilsV1.findByUniqueAttributes(atlasTypeRegistry.getEntityTypeByName(GlossaryUtils.ATLAS_GLOSSARY_TERM_TYPENAME), new HashMap<String, Object>() {{
+            put(QUALIFIED_NAME_ATTR, term.getQualifiedName());
+        }});
+        return Objects.nonNull(vertex);
+    }
+
+    private boolean categoryExists(AtlasGlossaryCategory category) {
+        AtlasVertex vertex = AtlasGraphUtilsV1.findByUniqueAttributes(atlasTypeRegistry.getEntityTypeByName(GlossaryUtils.ATLAS_GLOSSARY_CATEGORY_TYPENAME), new HashMap<String, Object>() {{
+            put(QUALIFIED_NAME_ATTR, category.getQualifiedName());
+        }});
+        return Objects.nonNull(vertex);
+    }
+
     private void deleteCategories(final AtlasGlossary existing, final Set<AtlasRelatedCategoryHeader> categories) throws AtlasBaseException {
         if (CollectionUtils.isNotEmpty(categories)) {
             if (DEBUG_ENABLED) {

repository/src/main/java/org/apache/atlas/glossary/GlossaryTermUtils.java

@@ -31,10 +31,12 @@ import org.apache.atlas.repository.store.graph.AtlasRelationshipStore;
 import org.apache.atlas.type.AtlasRelationshipType;
 import org.apache.atlas.type.AtlasTypeRegistry;
 import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.collections.MapUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
@@ -170,39 +172,42 @@ public class GlossaryTermUtils extends GlossaryUtils {
                 break;
             case UPDATE:
                 for (AtlasGlossaryTerm.Relation relation : AtlasGlossaryTerm.Relation.values()) {
-                    Set<AtlasRelatedTermHeader> existingTermHeaders = existingRelatedTerms.get(relation);
-                    Set<AtlasRelatedTermHeader> newTermHeaders      = newRelatedTerms.get(relation);
+                    Map<String, AtlasRelatedTermHeader> existingTermHeaders = getRelatedTermHeaders(existingRelatedTerms, relation);
+                    Map<String, AtlasRelatedTermHeader> newTermHeaders      = getRelatedTermHeaders(newRelatedTerms, relation);
 
                     // No existing term relations, create all
-                    if (CollectionUtils.isEmpty(existingTermHeaders)) {
+                    if (MapUtils.isEmpty(existingTermHeaders)) {
                         if (DEBUG_ENABLED) {
                             LOG.debug("Creating new term relations, relation = {}, terms = {}", relation,
                                       Objects.nonNull(newTermHeaders) ? newTermHeaders.size() : "none");
                         }
-                        createTermRelationships(existing, relation, newTermHeaders);
+                        createTermRelationships(existing, relation, newTermHeaders.values());
                         continue;
                     }
 
                     // Existing term relations but nothing in updated object, remove all
-                    if (CollectionUtils.isEmpty(newTermHeaders)) {
+                    if (MapUtils.isEmpty(newTermHeaders)) {
                         if (DEBUG_ENABLED) {
                             LOG.debug("Deleting existing term relations, relation = {}, terms = {}", relation, existingTermHeaders.size());
                         }
-                        deleteTermRelationships(relation, existingTermHeaders);
+                        deleteTermRelationships(relation, existingTermHeaders.values());
                         continue;
                     }
                     // Determine what to update, delete or create
                     Set<AtlasRelatedTermHeader> toCreate = newTermHeaders
+                                                                   .values()
                                                                    .stream()
-                                                                   .filter(t -> Objects.isNull(t.getRelationGuid()))
+                                                                   .filter(t -> !existingTermHeaders.containsKey(t.getTermGuid()))
                                                                    .collect(Collectors.toSet());
                     Set<AtlasRelatedTermHeader> toUpdate = newTermHeaders
+                                                                   .values()
                                                                    .stream()
-                                                                   .filter(t -> Objects.nonNull(t.getRelationGuid()) && existingTermHeaders.contains(t))
+                                                                   .filter(t -> updatedExistingTermRelation(existingTermHeaders, t))
                                                                    .collect(Collectors.toSet());
                     Set<AtlasRelatedTermHeader> toDelete = existingTermHeaders
+                                                                   .values()
                                                                    .stream()
-                                                                   .filter(t -> !toCreate.contains(t) && !toUpdate.contains(t))
+                                                                   .filter(t -> !newTermHeaders.containsKey(t.getTermGuid()))
                                                                    .collect(Collectors.toSet());
 
                     createTermRelationships(existing, relation, toCreate);
@@ -221,61 +226,88 @@ public class GlossaryTermUtils extends GlossaryUtils {
         }
     }
 
-    private void processAssociatedCategories(AtlasGlossaryTerm newObj, AtlasGlossaryTerm existing, RelationshipOperation op) throws AtlasBaseException {
-        Set<AtlasTermCategorizationHeader> newCategories      = newObj.getCategories();
-        Set<AtlasTermCategorizationHeader> existingCategories = existing.getCategories();
+    private Map<String, AtlasRelatedTermHeader> getRelatedTermHeaders(Map<AtlasGlossaryTerm.Relation, Set<AtlasRelatedTermHeader>> relatedTerms, AtlasGlossaryTerm.Relation relation) {
+        return Objects.nonNull(relatedTerms.get(relation)) ?
+                       relatedTerms.get(relation)
+                                   .stream()
+                                   .collect(Collectors.toMap(AtlasRelatedTermHeader::getTermGuid, t -> t)) :
+                       Collections.EMPTY_MAP;
+    }
+
+    private boolean updatedExistingTermRelation(Map<String, AtlasRelatedTermHeader> existingTermHeaders, AtlasRelatedTermHeader header) {
+        return Objects.nonNull(header.getRelationGuid()) && !header.equals(existingTermHeaders.get(header.getTermGuid()));
+    }
+
+    private void processAssociatedCategories(AtlasGlossaryTerm updatedTerm, AtlasGlossaryTerm existing, RelationshipOperation op) throws AtlasBaseException {
+        Map<String, AtlasTermCategorizationHeader> newCategories      = getAssociatedCategories(updatedTerm);
+        Map<String, AtlasTermCategorizationHeader> existingCategories = getAssociatedCategories(existing);
         switch (op) {
             case CREATE:
                 if (Objects.nonNull(newCategories)) {
                     if (DEBUG_ENABLED) {
                         LOG.debug("Creating new term categorization, term = {}, categories = {}", existing.getGuid(), newCategories.size());
                     }
-                    createTermCategorizationRelationships(existing, newCategories);
+                    createTermCategorizationRelationships(existing, newCategories.values());
                 }
                 break;
             case UPDATE:
                 // If no existing categories are present then create all existing ones
-                if (CollectionUtils.isEmpty(existingCategories)) {
+                if (MapUtils.isEmpty(existingCategories)) {
                     if (DEBUG_ENABLED) {
                         LOG.debug("Creating new term categorization, term = {}, categories = {}", existing.getGuid(),
                                   Objects.nonNull(newCategories) ? newCategories.size() : "none");
                     }
-                    createTermCategorizationRelationships(existing, newCategories);
+                    createTermCategorizationRelationships(existing, newCategories.values());
                     break;
                 }
 
                 // If no new categories are present then delete all existing ones
-                if (CollectionUtils.isEmpty(newCategories)) {
+                if (MapUtils.isEmpty(newCategories)) {
                     if (DEBUG_ENABLED) {
                         LOG.debug("Deleting term categorization, term = {}, categories = {}", existing.getGuid(), existingCategories.size());
                     }
-                    deleteCategorizationRelationship(existingCategories);
+                    deleteCategorizationRelationship(existingCategories.values());
                     break;
                 }
 
                 Set<AtlasTermCategorizationHeader> toCreate = newCategories
+                                                                      .values()
                                                                       .stream()
-                                                                      .filter(c -> Objects.isNull(c.getRelationGuid()))
+                                                                      .filter(c -> !existingCategories.containsKey(c.getCategoryGuid()))
                                                                       .collect(Collectors.toSet());
                 createTermCategorizationRelationships(existing, toCreate);
                 Set<AtlasTermCategorizationHeader> toUpdate = newCategories
+                                                                      .values()
                                                                       .stream()
-                                                                      .filter(c -> Objects.nonNull(c.getRelationGuid()) && existingCategories.contains(c))
+                                                                      .filter(c -> updatedExistingCategorizationRelation(existingCategories, c))
                                                                       .collect(Collectors.toSet());
                 updateTermCategorizationRelationships(existing, toUpdate);
                 Set<AtlasTermCategorizationHeader> toDelete = existingCategories
+                                                                      .values()
                                                                       .stream()
-                                                                      .filter(c -> !toCreate.contains(c) && !toUpdate.contains(c))
+                                                                      .filter(c -> !newCategories.containsKey(c.getCategoryGuid()))
                                                                       .collect(Collectors.toSet());
                 deleteCategorizationRelationship(toDelete);
                 break;
             case DELETE:
-                deleteCategorizationRelationship(existingCategories);
+                deleteCategorizationRelationship(existingCategories.values());
                 break;
         }
     }
 
-    private void createTermCategorizationRelationships(AtlasGlossaryTerm existing, Set<AtlasTermCategorizationHeader> categories) throws AtlasBaseException {
+    private boolean updatedExistingCategorizationRelation(Map<String, AtlasTermCategorizationHeader> existingCategories, AtlasTermCategorizationHeader header) {
+        return Objects.nonNull(header.getRelationGuid()) && !header.equals(existingCategories.get(header.getCategoryGuid()));
+    }
+
+    private Map<String, AtlasTermCategorizationHeader> getAssociatedCategories(final AtlasGlossaryTerm term) {
+        return Objects.nonNull(term.getCategories()) ?
+                       term.getCategories()
+                           .stream()
+                           .collect(Collectors.toMap(AtlasTermCategorizationHeader::getCategoryGuid, c -> c)) :
+                       Collections.EMPTY_MAP;
+    }
+
+    private void createTermCategorizationRelationships(AtlasGlossaryTerm existing, Collection<AtlasTermCategorizationHeader> categories) throws AtlasBaseException {
         if (CollectionUtils.isNotEmpty(categories)) {
             Set<AtlasTermCategorizationHeader> existingCategories = existing.getCategories();
             for (AtlasTermCategorizationHeader categorizationHeader : categories) {
@@ -293,7 +325,7 @@ public class GlossaryTermUtils extends GlossaryUtils {
         }
     }
 
-    private void updateTermCategorizationRelationships(AtlasGlossaryTerm existing, Set<AtlasTermCategorizationHeader> toUpdate) throws AtlasBaseException {
+    private void updateTermCategorizationRelationships(AtlasGlossaryTerm existing, Collection<AtlasTermCategorizationHeader> toUpdate) throws AtlasBaseException {
         if (CollectionUtils.isNotEmpty(toUpdate)) {
             for (AtlasTermCategorizationHeader categorizationHeader : toUpdate) {
                 if (DEBUG_ENABLED) {
@@ -306,7 +338,7 @@ public class GlossaryTermUtils extends GlossaryUtils {
         }
     }
 
-    private void deleteCategorizationRelationship(Set<AtlasTermCategorizationHeader> existingCategories) throws AtlasBaseException {
+    private void deleteCategorizationRelationship(Collection<AtlasTermCategorizationHeader> existingCategories) throws AtlasBaseException {
         if (CollectionUtils.isNotEmpty(existingCategories)) {
             for (AtlasTermCategorizationHeader categorizationHeader : existingCategories) {
                 if (DEBUG_ENABLED) {
@@ -317,11 +349,16 @@ public class GlossaryTermUtils extends GlossaryUtils {
         }
     }
 
-    private void createTermRelationships(AtlasGlossaryTerm existing, AtlasGlossaryTerm.Relation relation, Set<AtlasRelatedTermHeader> terms) throws AtlasBaseException {
+    private void createTermRelationships(AtlasGlossaryTerm existing, AtlasGlossaryTerm.Relation relation, Collection<AtlasRelatedTermHeader> terms) throws AtlasBaseException {
         if (CollectionUtils.isNotEmpty(terms)) {
-            Set<AtlasRelatedTermHeader> existingRelations = existing.getRelatedTerms().get(relation);
+            Map<String, AtlasRelatedTermHeader> existingRelations;
+            if (Objects.nonNull(existing.getRelatedTerms()) && Objects.nonNull(existing.getRelatedTerms().get(relation))) {
+                existingRelations = existing.getRelatedTerms().get(relation).stream().collect(Collectors.toMap(AtlasRelatedTermHeader::getTermGuid, t -> t));
+            } else {
+                existingRelations = Collections.EMPTY_MAP;
+            }
             for (AtlasRelatedTermHeader term : terms) {
-                if (Objects.nonNull(existingRelations) && existingRelations.contains(term)) {
+                if (Objects.nonNull(existingRelations) && existingRelations.containsKey(term.getTermGuid())) {
                     if (DEBUG_ENABLED) {
                         LOG.debug("Skipping existing term relation termGuid={}", term.getTermGuid());
                     }
@@ -335,7 +372,7 @@ public class GlossaryTermUtils extends GlossaryUtils {
         }
     }
 
-    private void updateTermRelationships(AtlasGlossaryTerm.Relation relation, Set<AtlasRelatedTermHeader> terms) throws AtlasBaseException {
+    private void updateTermRelationships(AtlasGlossaryTerm.Relation relation, Collection<AtlasRelatedTermHeader> terms) throws AtlasBaseException {
         if (CollectionUtils.isNotEmpty(terms)) {
             for (AtlasRelatedTermHeader term : terms) {
                 if (DEBUG_ENABLED) {
@@ -348,7 +385,7 @@ public class GlossaryTermUtils extends GlossaryUtils {
         }
     }
 
-    private void deleteTermRelationships(AtlasGlossaryTerm.Relation relation, Set<AtlasRelatedTermHeader> terms) throws AtlasBaseException {
+    private void deleteTermRelationships(AtlasGlossaryTerm.Relation relation, Collection<AtlasRelatedTermHeader> terms) throws AtlasBaseException {
         if (CollectionUtils.isNotEmpty(terms)) {
             for (AtlasRelatedTermHeader termHeader : terms) {
                 if (DEBUG_ENABLED) {

repository/src/main/java/org/apache/atlas/glossary/GlossaryUtils.java

@@ -36,8 +36,12 @@ public abstract class GlossaryUtils {
     public static final String TERM_ASSIGNMENT_ATTR_STEWARD     = "steward";
     public static final String TERM_ASSIGNMENT_ATTR_SOURCE      = "source";
 
-    static final String ATLAS_GLOSSARY_PREFIX = "__AtlasGlossary";
+    static final String ATLAS_GLOSSARY_TYPENAME          = "__AtlasGlossary";
+    static final String ATLAS_GLOSSARY_TERM_TYPENAME     = "__AtlasGlossaryTerm";
+    static final String ATLAS_GLOSSARY_CATEGORY_TYPENAME = "__AtlasGlossaryCategory";
+
     // Relation name constants
+    protected static final String ATLAS_GLOSSARY_PREFIX          = ATLAS_GLOSSARY_TYPENAME;
     protected static final String TERM_ANCHOR                    = ATLAS_GLOSSARY_PREFIX + "TermAnchor";
     protected static final String CATEGORY_ANCHOR                = ATLAS_GLOSSARY_PREFIX + "CategoryAnchor";
     protected static final String CATEGORY_HIERARCHY             = ATLAS_GLOSSARY_PREFIX + "CategoryHierarchyLink";
@@ -49,7 +53,6 @@ public abstract class GlossaryUtils {
     protected static final String TERM_RELATION_ATTR_SOURCE      = "source";
     protected static final String TERM_RELATION_ATTR_STATUS      = "status";
 
-
     protected final AtlasRelationshipStore relationshipStore;
     protected final AtlasTypeRegistry typeRegistry;
 

repository/src/main/java/org/apache/atlas/repository/store/graph/v1/EntityGraphRetriever.java

@@ -500,12 +500,8 @@ public final class EntityGraphRetriever {
         Iterable edges = entityVertex.query().direction(AtlasEdgeDirection.IN).label(TERM_ASSIGNMENT_LABEL).edges();
 
         if (edges != null) {
-            Iterator<AtlasEdge> iterator = edges.iterator();
-
-            while (iterator.hasNext()) {
-                AtlasEdge edge = iterator.next();
-
-                if (edge != null) {
+            for (final AtlasEdge edge : (Iterable<AtlasEdge>) edges) {
+                if (edge != null && GraphHelper.getStatus(edge) != AtlasEntity.Status.DELETED) {
                     ret.add(toTermAssignmentHeader(edge));
                 }
             }

repository/src/test/java/org/apache/atlas/glossary/GlossaryServiceTest.java

@@ -39,6 +39,7 @@ import org.apache.atlas.repository.store.graph.v1.AtlasEntityStream;
 import org.apache.atlas.store.AtlasTypeDefStore;
 import org.apache.atlas.type.AtlasTypeRegistry;
 import org.apache.atlas.utils.AtlasJson;
+import org.apache.commons.collections.CollectionUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.testng.SkipException;
@@ -55,10 +56,7 @@ import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 
-import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.assertNotNull;
-import static org.testng.Assert.assertNull;
-import static org.testng.Assert.fail;
+import static org.testng.Assert.*;
 
 @Guice(modules = TestModules.TestOnlyModule.class)
 public class GlossaryServiceTest {
@@ -96,10 +94,8 @@ public class GlossaryServiceTest {
         } catch (AtlasBaseException | IOException e) {
             throw new SkipException("SubjectArea model loading failed");
         }
-    }
 
-    @Test(groups = "Glossary.CREATE")
-    public void testCreateGlossary() {
+        // Glossary
         bankGlossary = new AtlasGlossary();
         bankGlossary.setQualifiedName("testBankingGlossary");
         bankGlossary.setDisplayName("Banking glossary");
@@ -116,34 +112,26 @@ public class GlossaryServiceTest {
         creditUnionGlossary.setUsage("N/A");
         creditUnionGlossary.setLanguage("en-US");
 
-        try {
-            AtlasGlossary created = glossaryService.createGlossary(bankGlossary);
-            bankGlossary.setGuid(created.getGuid());
-            created = glossaryService.createGlossary(creditUnionGlossary);
-            creditUnionGlossary.setGuid(created.getGuid());
-        } catch (AtlasBaseException e) {
-            fail("Glossary creation should've succeeded", e);
-        }
-
-        // Glossary anchor
-        AtlasGlossaryHeader glossaryId = new AtlasGlossaryHeader();
-        glossaryId.setGlossaryGuid(bankGlossary.getGuid());
-
-        // Create a category
+        // Category
         accountCategory = new AtlasGlossaryCategory();
         accountCategory.setQualifiedName("acc@testBankingGlossary");
         accountCategory.setDisplayName("Account categorization");
         accountCategory.setShortDescription("Short description");
         accountCategory.setLongDescription("Long description");
-        accountCategory.setAnchor(glossaryId);
 
-        try {
-            accountCategory = glossaryService.createCategory(accountCategory);
-        } catch (AtlasBaseException e) {
-            fail("Account category creation should've succeeded");
-        }
+        customerCategory = new AtlasGlossaryCategory();
+        customerCategory.setQualifiedName("customer@testBankingGlossary");
+        customerCategory.setDisplayName("Customer category");
+        customerCategory.setShortDescription("Short description");
+        customerCategory.setLongDescription("Long description");
 
-        // Create terms
+        mortgageCategory = new AtlasGlossaryCategory();
+        mortgageCategory.setQualifiedName("mtg@testBankingGlossary");
+        mortgageCategory.setDisplayName("Mortgage categorization");
+        mortgageCategory.setShortDescription("Short description");
+        mortgageCategory.setLongDescription("Long description");
+
+        // Terms
         checkingAccount = new AtlasGlossaryTerm();
         checkingAccount.setQualifiedName("chk_acc@testBankingGlossary");
         checkingAccount.setDisplayName("A checking account");
@@ -152,7 +140,6 @@ public class GlossaryServiceTest {
         checkingAccount.setAbbreviation("CHK");
         checkingAccount.setExamples(Arrays.asList("Personal", "Joint"));
         checkingAccount.setUsage("N/A");
-        checkingAccount.setAnchor(glossaryId);
 
         savingsAccount = new AtlasGlossaryTerm();
         savingsAccount.setQualifiedName("sav_acc@testBankingGlossary");
@@ -162,7 +149,6 @@ public class GlossaryServiceTest {
         savingsAccount.setAbbreviation("SAV");
         savingsAccount.setExamples(Arrays.asList("Personal", "Joint"));
         savingsAccount.setUsage("N/A");
-        savingsAccount.setAnchor(glossaryId);
 
         fixedRateMortgage = new AtlasGlossaryTerm();
         fixedRateMortgage.setQualifiedName("fixed_mtg@testBankingGlossary");
@@ -172,7 +158,6 @@ public class GlossaryServiceTest {
         fixedRateMortgage.setAbbreviation("FMTG");
         fixedRateMortgage.setExamples(Arrays.asList("15-yr", "30-yr"));
         fixedRateMortgage.setUsage("N/A");
-        fixedRateMortgage.setAnchor(glossaryId);
 
         adjustableRateMortgage = new AtlasGlossaryTerm();
         adjustableRateMortgage.setQualifiedName("arm_mtg@testBankingGlossary");
@@ -182,25 +167,53 @@ public class GlossaryServiceTest {
         adjustableRateMortgage.setAbbreviation("ARMTG");
         adjustableRateMortgage.setExamples(Arrays.asList("5/1", "7/1", "10/1"));
         adjustableRateMortgage.setUsage("N/A");
+
+
+    }
+
+    @Test(groups = "Glossary.CREATE")
+    public void testCreateGlossary() {
+        try {
+            AtlasGlossary created = glossaryService.createGlossary(bankGlossary);
+            bankGlossary.setGuid(created.getGuid());
+            created = glossaryService.createGlossary(creditUnionGlossary);
+            creditUnionGlossary.setGuid(created.getGuid());
+        } catch (AtlasBaseException e) {
+            fail("Glossary creation should've succeeded", e);
+        }
+
+        // Duplicate create calls should fail with 409 Conflict
+        try {
+            glossaryService.createGlossary(bankGlossary);
+            fail("Glossary duplicate creation should've failed");
+        } catch (AtlasBaseException e) {
+            assertEquals(e.getAtlasErrorCode(), AtlasErrorCode.GLOSSARY_ALREADY_EXISTS);
+        }
+        try {
+            glossaryService.createGlossary(creditUnionGlossary);
+            fail("Glossary duplicate creation should've failed");
+        } catch (AtlasBaseException e) {
+            assertEquals(e.getAtlasErrorCode(), AtlasErrorCode.GLOSSARY_ALREADY_EXISTS);
+        }
+
+        // Glossary anchor
+        AtlasGlossaryHeader glossaryId = new AtlasGlossaryHeader();
+        glossaryId.setGlossaryGuid(bankGlossary.getGuid());
+
+        // Create terms
+        checkingAccount.setAnchor(glossaryId);
+        savingsAccount.setAnchor(glossaryId);
+        fixedRateMortgage.setAnchor(glossaryId);
+
         adjustableRateMortgage.setAnchor(glossaryId);
 
         // Create glossary categories
-        customerCategory = new AtlasGlossaryCategory();
-        customerCategory.setQualifiedName("customer@testBankingGlossary");
-        customerCategory.setDisplayName("Customer category");
-        customerCategory.setShortDescription("Short description");
-        customerCategory.setLongDescription("Long description");
+        accountCategory.setAnchor(glossaryId);
         customerCategory.setAnchor(glossaryId);
-
-        mortgageCategory = new AtlasGlossaryCategory();
-        mortgageCategory.setQualifiedName("mtg@testBankingGlossary");
-        mortgageCategory.setDisplayName("Mortgage categorization");
-        mortgageCategory.setShortDescription("Short description");
-        mortgageCategory.setLongDescription("Long description");
         mortgageCategory.setAnchor(glossaryId);
     }
 
-    @Test(groups = "Glossary.CREATE" , dependsOnMethods = "testCreateGlossary")
+    @Test(groups = "Glossary.CREATE" , dependsOnMethods = "testCategoryCreation")
     public void testTermCreationWithoutAnyRelations() {
         try {
             checkingAccount = glossaryService.createTerm(checkingAccount);
@@ -231,11 +244,11 @@ public class GlossaryServiceTest {
         }
     }
 
-    @Test(groups = "Glossary.CREATE" , dependsOnMethods = "testCreateGlossary")
+    @Test(groups = "Glossary.CREATE" , dependsOnMethods = "testCategoryCreation")
     public void testTermCreationWithCategory() {
         try {
             AtlasTermCategorizationHeader termCategorizationHeader = new AtlasTermCategorizationHeader();
-            termCategorizationHeader.setCategoryGuid(accountCategory.getGuid());
+            termCategorizationHeader.setCategoryGuid(mortgageCategory.getGuid());
             termCategorizationHeader.setDescription("Test description");
             termCategorizationHeader.setStatus(AtlasTermRelationshipStatus.DRAFT);
 
@@ -253,8 +266,16 @@ public class GlossaryServiceTest {
     @Test(groups = "Glossary.CREATE" , dependsOnMethods = "testCreateGlossary")
     public void testCategoryCreation() {
         try {
-            List<AtlasGlossaryCategory> categories = glossaryService.createCategories(Arrays.asList(customerCategory, mortgageCategory));
-            customerCategory.setGuid(categories.get(0).getGuid());
+            customerCategory = glossaryService.createCategory(customerCategory);
+
+            AtlasRelatedCategoryHeader parentHeader = new AtlasRelatedCategoryHeader();
+            parentHeader.setCategoryGuid(customerCategory.getGuid());
+
+            // Test parent relation
+            accountCategory.setParentCategory(parentHeader);
+            List<AtlasGlossaryCategory> categories = glossaryService.createCategories(Arrays.asList(accountCategory, mortgageCategory));
+
+            accountCategory.setGuid(categories.get(0).getGuid());
             mortgageCategory.setGuid(categories.get(1).getGuid());
         } catch (AtlasBaseException e) {
             fail("Category creation should've succeeded", e);
@@ -390,15 +411,21 @@ public class GlossaryServiceTest {
             savingsAccount = glossaryService.getTerm(savingsAccount.getGuid());
 
             checkingAccount.setAnchor(newGlossaryHeader);
+            checkingAccount.setSeeAlso(null);
             savingsAccount.setAnchor(newGlossaryHeader);
+            savingsAccount.setSeeAlso(null);
 
         } catch (AtlasBaseException e) {
             fail("Term fetch for migration should've succeeded", e);
         }
 
         try {
-            glossaryService.updateTerm(checkingAccount);
-            glossaryService.updateTerm(savingsAccount);
+            checkingAccount = glossaryService.updateTerm(checkingAccount);
+            assertNotNull(checkingAccount);
+            assertTrue(CollectionUtils.isEmpty(checkingAccount.getSeeAlso()));
+            savingsAccount = glossaryService.updateTerm(savingsAccount);
+            assertNotNull(savingsAccount);
+            assertTrue(CollectionUtils.isEmpty(savingsAccount.getSeeAlso()));
         } catch (AtlasBaseException e) {
             fail("Term anchor change should've succeeded", e);
         }
@@ -426,9 +453,11 @@ public class GlossaryServiceTest {
         }
 
         customerCategory.setAnchor(newGlossaryHeader);
+        customerCategory.setChildrenCategories(null);
 
         try {
-            glossaryService.updateCategory(customerCategory);
+            customerCategory = glossaryService.updateCategory(customerCategory);
+            assertTrue(CollectionUtils.isEmpty(customerCategory.getChildrenCategories()));
         } catch (AtlasBaseException e) {
             fail("Category anchor change should've succeeded");
         }
@@ -447,6 +476,7 @@ public class GlossaryServiceTest {
         assertNotNull(accountCategory);
         try {
             accountCategory = glossaryService.getCategory(accountCategory.getGuid());
+            assertTrue(CollectionUtils.isEmpty(accountCategory.getTerms()));
         } catch (AtlasBaseException e) {
             fail("Fetch of accountCategory should've succeeded", e);
         }
@@ -515,24 +545,17 @@ public class GlossaryServiceTest {
         assertNotNull(customerCategory);
         try {
             customerCategory = glossaryService.getCategory(customerCategory.getGuid());
+            assertNull(customerCategory.getParentCategory());
+            assertNotNull(customerCategory.getChildrenCategories());
+            assertEquals(customerCategory.getChildrenCategories().size(), 1); // Only account category
         } catch (AtlasBaseException e) {
             fail("Fetch of accountCategory should've succeeded", e);
         }
-        List<AtlasGlossaryCategory> categories = new ArrayList<>();
-        for (AtlasGlossaryCategory category : Arrays.asList(accountCategory, mortgageCategory)) {
-            try {
-                categories.add(glossaryService.getCategory(category.getGuid()));
-            } catch (AtlasBaseException e) {
-                fail("Category fetch should've succeeded");
-            }
-        }
 
-        for (AtlasGlossaryCategory category : categories) {
         AtlasRelatedCategoryHeader id = new AtlasRelatedCategoryHeader();
-            id.setCategoryGuid(category.getGuid());
+        id.setCategoryGuid(mortgageCategory.getGuid());
         id.setDescription("Sub-category of customer");
         customerCategory.addChild(id);
-        }
 
         try {
             AtlasGlossaryCategory updateGlossaryCategory = glossaryService.updateCategory(customerCategory);
@@ -544,7 +567,7 @@ public class GlossaryServiceTest {
             fail("Sub category addition should've succeeded", e);
         }
 
-        for (AtlasGlossaryCategory childCategory : categories) {
+        for (AtlasGlossaryCategory childCategory : Arrays.asList(accountCategory, mortgageCategory)) {
             try {
                 AtlasGlossaryCategory child = glossaryService.getCategory(childCategory.getGuid());
                 assertNotNull(child);

webapp/src/main/java/org/apache/atlas/web/rest/GlossaryREST.java

@@ -214,6 +214,7 @@ public class GlossaryREST {
      * @throws AtlasBaseException
      * @HTTP 200 If glossary creation was successful
      * @HTTP 400 If Glossary definition has invalid or missing information
+     * @HTTP 409 If Glossary definition already exists (duplicate qualifiedName)
      */
     @POST
     public AtlasGlossary createGlossary(AtlasGlossary atlasGlossary) throws AtlasBaseException {
@@ -236,6 +237,7 @@ public class GlossaryREST {
      * @throws AtlasBaseException
      * @HTTP 200 If glossary term creation was successful
      * @HTTP 400 If Glossary term definition has invalid or missing information
+     * @HTTP 409 If Glossary term already exists (duplicate qualifiedName)
      */
     @POST
     @Path("/term")
@@ -289,6 +291,7 @@ public class GlossaryREST {
      * @throws AtlasBaseException
      * @HTTP 200 If glossary category creation was successful
      * @HTTP 400 If Glossary category definition has invalid or missing information
+     * @HTTP 409 If Glossary category already exists (duplicate qualifiedName)
      */
     @POST
     @Path("/category")