webapp/src/test/java/org/apache/atlas/web/integration/GlossaryClientV2IT.java - atlas - Git at Google

 /**
  * 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.integration;

 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.sun.jersey.api.client.ClientResponse;
 import org.apache.atlas.AtlasClientV2;
 import org.apache.atlas.AtlasServiceException;
 import org.apache.atlas.bulkimport.BulkImportResponse;
 import org.apache.atlas.model.glossary.AtlasGlossary;
 import org.apache.atlas.model.glossary.AtlasGlossaryCategory;
 import org.apache.atlas.model.glossary.AtlasGlossaryTerm;
 import org.apache.atlas.model.glossary.enums.AtlasTermRelationshipStatus;
 import org.apache.atlas.model.glossary.relations.AtlasGlossaryHeader;
 import org.apache.atlas.model.glossary.relations.AtlasRelatedCategoryHeader;
 import org.apache.atlas.model.glossary.relations.AtlasRelatedTermHeader;
 import org.apache.atlas.model.instance.AtlasEntity;
 import org.apache.atlas.model.instance.AtlasEntityHeader;
 import org.apache.atlas.model.instance.AtlasRelatedObjectId;
 import org.apache.atlas.model.typedef.AtlasTypesDef;
 import org.apache.atlas.type.AtlasType;
 import org.apache.atlas.utils.AuthenticationUtil;
 import org.apache.atlas.utils.TestResourceFileUtils;
 import org.apache.atlas.web.TestUtils;
 import org.apache.commons.io.FileUtils;
 import org.apache.commons.lang.RandomStringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;

 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertNotNull;
 import static org.testng.Assert.assertNull;
 import static org.testng.Assert.fail;

 public class GlossaryClientV2IT extends BaseResourceIT {
     private static final Logger LOG = LoggerFactory.getLogger(GlossaryClientV2IT.class);
     private static final ObjectMapper mapper = new ObjectMapper();

     private AtlasTypesDef typeDefinitions;
     private AtlasClientV2 clientV2;
     private AtlasGlossary educationGlossary, healthCareGlossary;
     private AtlasGlossaryTerm educationTerm, schoolEducationTerm;
     private AtlasGlossaryCategory educationCategory;
     private List<AtlasRelatedObjectId> relatedObjectIds;
     private AtlasEntityHeader entityHeader;

     @BeforeClass
     public void setUp() throws Exception {
         super.setUp();
         typeDefinitions = setForGlossary();
         createType(typeDefinitions);

         if (!AuthenticationUtil.isKerberosAuthenticationEnabled()) {
             clientV2 = new AtlasClientV2(atlasUrls, new String[]{"admin", "admin"});
         } else {
             clientV2 = new AtlasClientV2(atlasUrls);
         }
     }

     @AfterClass
     public void tearDown() throws Exception {
         emptyTypeDefs(typeDefinitions);
     }

     @Test
     public void testCreateGlossary() throws Exception {
         educationGlossary = createAndGetGlossary("Education");
         assertNotNull(educationGlossary);
     }

     @Test(dependsOnMethods = "testCreateGlossary")
     public void testGetGlossaryByGuid() throws Exception {
         healthCareGlossary = createAndGetGlossary("HealthCare");
         AtlasGlossary atlasGlossaryByGuid = atlasClientV2.getGlossaryByGuid(healthCareGlossary.getGuid());
         assertNotNull(atlasGlossaryByGuid);
         assertEquals(healthCareGlossary.getGuid(), atlasGlossaryByGuid.getGuid());
     }

     @Test(dependsOnMethods = "testCreateGlossary")
     public void testGetDetailGlossary() throws Exception {
         AtlasGlossary.AtlasGlossaryExtInfo extInfo = atlasClientV2.getGlossaryExtInfo(educationGlossary.getGuid());
         assertNotNull(extInfo);
         assertEquals(educationGlossary.getGuid(), extInfo.getGuid());
     }

     @Test(dependsOnMethods = "testGetGlossaryByGuid")
     public void getAllGlossary() throws Exception {
         List<AtlasGlossary> list = atlasClientV2.getAllGlossaries("ASC", 5, 0);
         assertNotNull(list);
         assertEquals(list.size(), 3);
     }

     @Test(dependsOnMethods = "testCreateGlossary")
     public void updateGlossaryByGuid() throws Exception {
         AtlasGlossary newGlossary = new AtlasGlossary();
         newGlossary.setLanguage("English");
         newGlossary.setName("updateGlossary");
         AtlasGlossary updated = atlasClientV2.updateGlossaryByGuid(educationGlossary.getGuid(), newGlossary);
         assertNotNull(updated);
         assertEquals(updated.getGuid(), educationGlossary.getGuid());
         assertEquals(updated.getLanguage(), newGlossary.getLanguage());
     }

     @Test(dependsOnMethods = "testCreateGlossary")
     public void testCreateTerm() throws Exception {
         AtlasGlossaryTerm term = new AtlasGlossaryTerm();
         AtlasGlossaryHeader header = new AtlasGlossaryHeader();
         header.setGlossaryGuid(educationGlossary.getGuid());
         header.setDisplayText(educationGlossary.getName());
         term.setAnchor(header);
         term.setName("termForEducation");
         educationTerm = atlasClientV2.createGlossaryTerm(term);
         assertNotNull(educationTerm);
         assertNotNull(educationTerm.getGuid());
     }

     @Test(dependsOnMethods = "testCreateTerm")
     public void testGetGlossaryTerm() throws Exception {
         AtlasGlossaryTerm term = atlasClientV2.getGlossaryTerm(educationTerm.getGuid());
         assertNotNull(term);
         assertEquals(term.getGuid(), educationTerm.getGuid());
     }

     @Test(dependsOnMethods = "testCreateTerm")
     public void testGetGlossaryTerms() throws Exception {
         AtlasRelatedTermHeader relatedTermHeader = new AtlasRelatedTermHeader();
         relatedTermHeader.setTermGuid(educationTerm.getGuid());
         relatedTermHeader.setDescription("test description");
         relatedTermHeader.setExpression("test expression");
         relatedTermHeader.setSource("School");
         relatedTermHeader.setSteward("School");
         relatedTermHeader.setStatus(AtlasTermRelationshipStatus.ACTIVE);
         schoolEducationTerm = new AtlasGlossaryTerm();
         AtlasGlossaryHeader header = new AtlasGlossaryHeader();
         header.setGlossaryGuid(educationGlossary.getGuid());
         header.setDisplayText(educationGlossary.getName());
         schoolEducationTerm.setAnchor(header);
         schoolEducationTerm.setName("termForSchool");
         schoolEducationTerm.setSeeAlso(Collections.singleton(relatedTermHeader));

         schoolEducationTerm = clientV2.createGlossaryTerm(schoolEducationTerm);
         assertNotNull(schoolEducationTerm);
         assertNotNull(schoolEducationTerm.getGuid());

         //Getting multiple terms
         List<AtlasGlossaryTerm> terms = atlasClientV2.getGlossaryTerms(educationGlossary.getGuid(), "ASC", 2, 0);
         assertNotNull(terms);
         assertEquals(terms.size(), 2);
     }

     @Test(dependsOnMethods = "testCreateGlossary")
     public void testCreateGlossaryCategory() throws Exception {
         AtlasGlossaryCategory category = new AtlasGlossaryCategory();
         AtlasGlossaryHeader header = new AtlasGlossaryHeader();
         header.setGlossaryGuid(educationGlossary.getGuid());
         header.setDisplayText(educationGlossary.getName());
         category.setAnchor(header);
         category.setName("categoryForEducation");
         educationCategory = atlasClientV2.createGlossaryCategory(category);
         assertNotNull(educationCategory);
         assertNotNull(educationCategory.getGuid());
     }

     @Test(dependsOnMethods = "testCreateGlossaryCategory")
     public void testCreateGlossaryCategories() throws Exception {
         List<AtlasGlossaryCategory> glossaryCategories = new ArrayList<>();

         AtlasGlossaryCategory category1 = new AtlasGlossaryCategory();
         AtlasGlossaryHeader header1 = new AtlasGlossaryHeader();
         header1.setGlossaryGuid(healthCareGlossary.getGuid());
         header1.setDisplayText(healthCareGlossary.getName());
         category1.setAnchor(header1);
         category1.setName("category1ForEducation");
         glossaryCategories.add(category1);
         //Setting different category
         AtlasGlossaryCategory category2 = new AtlasGlossaryCategory();
         category2.setAnchor(header1);
         category2.setName("category2ForEducation");
         glossaryCategories.add(category2);

         List<AtlasGlossaryCategory> list = atlasClientV2.createGlossaryCategories(glossaryCategories);
         assertNotNull(list);
         assertEquals(list.size(), 2);
     }

     @Test(dependsOnMethods = "testCreateGlossaryCategory")
     public void testGetGlossaryByCategory() throws Exception {
         AtlasGlossaryCategory atlasGlossaryCategory = atlasClientV2.getGlossaryCategory(educationCategory.getGuid());
         assertNotNull(atlasGlossaryCategory);
         assertEquals(atlasGlossaryCategory.getGuid(), educationCategory.getGuid());
     }

     @Test(dependsOnMethods = "testGetGlossaryByGuid")
     public void testCreateGlossaryTerms() throws Exception {
         List<AtlasGlossaryTerm> list = new ArrayList<>();
         int index = 0;
         List<AtlasGlossary> glossaries = atlasClientV2.getAllGlossaries("ASC", 5, 0);
         List<AtlasGlossary> glossaryList = mapper.convertValue(
                 glossaries,
                 new TypeReference<List<AtlasGlossary>>() {
                 });

         for (AtlasGlossary glossary : glossaryList) {
             AtlasGlossaryTerm term = new AtlasGlossaryTerm();
             AtlasGlossaryHeader header = new AtlasGlossaryHeader();
             header.setGlossaryGuid(glossary.getGuid());
             header.setDisplayText(glossary.getName());
             term.setAnchor(header);
             term.setName("termName" + index);
             list.add(term);
             index++;
         }
         List<AtlasGlossaryTerm> termList = atlasClientV2.createGlossaryTerms(list);
         assertNotNull(termList);
         assertEquals(termList.size(), 3);
     }

     @Test(dependsOnMethods = "testCreateGlossary")
     public void testPartialUpdateGlossaryByGuid() throws Exception {
         Map<String, String> partialUpdates = new HashMap<>();
         partialUpdates.put("shortDescription", "shortDescription");
         partialUpdates.put("longDescription", "longDescription");
         AtlasGlossary atlasGlossary = atlasClientV2.partialUpdateGlossaryByGuid(educationGlossary.getGuid(), partialUpdates);
         assertNotNull(atlasGlossary);
         assertEquals(atlasGlossary.getShortDescription(), "shortDescription");
         assertEquals(atlasGlossary.getLongDescription(), "longDescription");
     }

     @Test(dependsOnMethods = "testCreateGlossary")
     public void testUpdateGlossaryTermByGuid() throws Exception {
         AtlasGlossaryTerm term = new AtlasGlossaryTerm(educationTerm);
         term.setAbbreviation("trm");
         AtlasGlossaryTerm responseTerm = atlasClientV2.updateGlossaryTermByGuid(educationTerm.getGuid(), term);
         assertNotNull(responseTerm);
         assertEquals(responseTerm.getAbbreviation(), term.getAbbreviation());
     }

     @Test(dependsOnMethods = "testCreateGlossary")
     public void testUpdateGlossaryCategoryByGuid() throws Exception {
         AtlasGlossaryCategory category = new AtlasGlossaryCategory(educationCategory);
         category.setLongDescription("this is about category");
         AtlasGlossaryCategory responseCategory = atlasClientV2.updateGlossaryCategoryByGuid(educationCategory.getGuid(), category);
         assertNotNull(responseCategory);
         assertEquals(responseCategory.getLongDescription(), category.getLongDescription());
     }

     @Test(dependsOnMethods = "testCreateGlossary")
     public void testPartialUpdateTermByGuid() throws Exception {
         Map<String, String> partialUpdates = new HashMap<>();
         partialUpdates.put("shortDescription", "shortDescriptionTerm");
         partialUpdates.put("longDescription", "longDescriptionTerm");

         AtlasGlossaryTerm term = atlasClientV2.partialUpdateTermByGuid(educationTerm.getGuid(), partialUpdates);
         assertNotNull(term);
         assertEquals(term.getShortDescription(), "shortDescriptionTerm");
         assertEquals(term.getLongDescription(), "longDescriptionTerm");
     }

     @Test(dependsOnMethods = "testCreateGlossary")
     public void testPartialUpdateCategoryByGuid() throws Exception {
         Map<String, String> partialUpdates = new HashMap<>();
         partialUpdates.put("shortDescription", "shortDescriptionCategory");
         partialUpdates.put("longDescription", "longDescriptionCategory");

         AtlasGlossaryCategory category = atlasClientV2.partialUpdateCategoryByGuid(educationCategory.getGuid(), partialUpdates);
         assertNotNull(category);
         assertEquals(category.getShortDescription(), "shortDescriptionCategory");
         assertEquals(category.getLongDescription(), "longDescriptionCategory");
     }

     @Test(dependsOnMethods = "testCreateGlossary")
     public void testGetGlossaryTermHeadersByGuid() throws Exception {
         List<AtlasRelatedTermHeader> list = atlasClientV2.getGlossaryTermHeaders(educationGlossary.getGuid(), "ASC", 2, 0);
         assertNotNull(list);
         assertEquals(list.size(), 1);
     }

     @Test(dependsOnMethods = "testCreateGlossaryCategories")
     public void testGetGlossaryCategoriesByGuid() throws Exception {
         List<AtlasGlossaryCategory> list = atlasClientV2.getGlossaryCategories(healthCareGlossary.getGuid(), "ASC", 2, 0);
         assertNotNull(list);
         assertEquals(list.size(), 2);
     }

     @Test(dependsOnMethods = "testCreateGlossaryCategories")
     public void testGetGlossaryCategoryHeaders() throws Exception {
         List<AtlasRelatedCategoryHeader> list = atlasClientV2.getGlossaryCategoryHeaders(healthCareGlossary.getGuid(), "ASC", 2, 0);
         assertNotNull(list);
         assertEquals(list.size(), 2);
     }

     @Test(dependsOnMethods = "testCreateGlossary")
     public void testGetCategoryTerms() throws Exception {
         List<AtlasRelatedTermHeader> list = atlasClientV2.getCategoryTerms(educationCategory.getGuid(), "ASC", 2, 0);
         assertNotNull(list);
         assertEquals(list.size(), 0);
     }

     @Test(dependsOnMethods = "testCreateGlossary")
     public void testGetAllRelatedTerms() throws Exception {
         Map<AtlasGlossaryTerm.Relation, Set<AtlasRelatedTermHeader>> map = atlasClientV2.getRelatedTerms(educationTerm.getGuid(), "ASC", 2, 0);
         assertNotNull(map);
     }

     @Test(dependsOnMethods = "testCreateTerm")
     public void testAssignTermToEntities() throws Exception {
         try {
             AtlasEntity entity = new AtlasEntity("Asset");
             entity.setAttribute("qualifiedName", "testAsset");
             entity.setAttribute("name", "testAsset");
             if (entityHeader == null) {
                 entityHeader = createEntity(entity);
             }
             AtlasRelatedObjectId relatedObjectId = new AtlasRelatedObjectId();
             relatedObjectId.setGuid(entityHeader.getGuid());
             relatedObjectId.setTypeName(entityHeader.getTypeName());
             assertNotNull(relatedObjectId);
             relatedObjectIds = new ArrayList<>();
             relatedObjectIds.add(relatedObjectId);

             atlasClientV2.assignTermToEntities(educationTerm.getGuid(), relatedObjectIds);
             List<AtlasRelatedObjectId> assignedEntities = atlasClientV2.getEntitiesAssignedWithTerm(educationTerm.getGuid(), "ASC", 2, 0);
             assertNotNull(assignedEntities);
             assertEquals(assignedEntities.size(), 1);
             List<AtlasRelatedObjectId> entityList = mapper.convertValue(
                     assignedEntities,
                     new TypeReference<List<AtlasRelatedObjectId>>() {
                     });
             String relationshipGuid = entityList.get(0).getRelationshipGuid();
             assertNotNull(relationshipGuid);
             relatedObjectId.setRelationshipGuid(relationshipGuid);

         } catch (Exception e) {
             e.printStackTrace();
         }

     }

     @Test(dependsOnMethods = "testAssignTermToEntities")
     public void testDisassociateTermAssignmentFromEntities() throws Exception {
         atlasClientV2.disassociateTermFromEntities(educationTerm.getGuid(), relatedObjectIds);
         AtlasGlossaryTerm term = atlasClientV2.getGlossaryTerm(educationTerm.getGuid());
         atlasClientV2.deleteEntityByGuid(entityHeader.getGuid());
         assertNotNull(term);
         assertNull(term.getAssignedEntities());
     }

     @Test(dependsOnMethods = "testCreateGlossaryCategory")
     public void testGetRelatedCategories() throws Exception {
         Map<String, List<AtlasRelatedCategoryHeader>> map = atlasClientV2.getRelatedCategories(educationCategory.getGuid(), "ASC", 1, 0);
         assertEquals(map.size(), 0);
     }

     @Test(dependsOnMethods = "testDeleteGlossaryTerm")
     public void testDeleteGlossary() throws Exception {
         emptyTypeDefs(typeDefinitions);
         atlasClientV2.deleteGlossaryByGuid(educationGlossary.getGuid());
         atlasClientV2.deleteGlossaryByGuid(healthCareGlossary.getGuid());
         try {
             atlasClientV2.getGlossaryByGuid(healthCareGlossary.getGuid());
         } catch (AtlasServiceException ex) {
             assertNotNull(ex.getStatus());
             assertEquals(ex.getStatus(), ClientResponse.Status.NOT_FOUND);
         }
         try {
             atlasClientV2.getGlossaryByGuid(educationGlossary.getGuid());
         } catch (AtlasServiceException ex) {
             assertNotNull(ex.getStatus());
             assertEquals(ex.getStatus(), ClientResponse.Status.NOT_FOUND);
         }
     }

     @Test(dependsOnMethods = "testDisassociateTermAssignmentFromEntities")
     public void testDeleteGlossaryTerm() throws Exception {
         atlasClientV2.deleteGlossaryTermByGuid(educationTerm.getGuid());
         try {
             atlasClientV2.getGlossaryTerm(educationTerm.getGuid());
         } catch (AtlasServiceException ex) {
             assertNotNull(ex.getStatus());
             assertEquals(ex.getStatus(), ClientResponse.Status.NOT_FOUND);
         }
     }

     @Test(dependsOnMethods = "testGetRelatedCategories")
     public void testDeleteGlossaryCategory() throws Exception {
         atlasClientV2.deleteGlossaryCategoryByGuid(educationCategory.getGuid());
         try {
             atlasClientV2.getGlossaryCategory(educationCategory.getGuid());
         } catch (AtlasServiceException ex) {
             assertNotNull(ex.getStatus());
             assertEquals(ex.getStatus(), ClientResponse.Status.NOT_FOUND);
         }
     }

     @Test()
     public void testProduceTemplate() {
         try {
             String template = atlasClientV2.getGlossaryImportTemplate();

             assertNotNull(template);
         } catch (AtlasServiceException ex) {
             fail("Deletion should've succeeded");
         }
     }

     @Test()
     public void testImportGlossaryData() {
         try {
             String             filePath = TestResourceFileUtils.getTestFilePath("template.csv");
             BulkImportResponse terms    = atlasClientV2.importGlossary(filePath);

             assertNotNull(terms);

             assertEquals(terms.getSuccessImportInfoList().size(), 1);

         } catch (AtlasServiceException ex) {
             fail("Import GlossaryData should've succeeded : "+ex);
         }
     }

     private AtlasGlossary createAndGetGlossary(String name) throws Exception {
         AtlasGlossary atlasGlossary = new AtlasGlossary();
         atlasGlossary.setName(name);
         return atlasClientV2.createGlossary(atlasGlossary);
     }

     private void emptyTypeDefs(AtlasTypesDef def) {
         def.getEnumDefs().clear();
         def.getStructDefs().clear();
         def.getClassificationDefs().clear();
         def.getEntityDefs().clear();
         def.getRelationshipDefs().clear();
         def.getBusinessMetadataDefs().clear();
     }

     private AtlasTypesDef setForGlossary() throws IOException {
         String filePath = TestUtils.getGlossaryType();
         String json = FileUtils.readFileToString(new File(filePath));
         return AtlasType.fromJson(json, AtlasTypesDef.class);
     }

     protected String randomString() {
         //names cannot start with a digit
         return RandomStringUtils.randomAlphabetic(1) + RandomStringUtils.randomAlphanumeric(9);
     }

 }
	/**
	* 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.integration;

	import com.fasterxml.jackson.core.type.TypeReference;
	import com.fasterxml.jackson.databind.ObjectMapper;
	import com.sun.jersey.api.client.ClientResponse;
	import org.apache.atlas.AtlasClientV2;
	import org.apache.atlas.AtlasServiceException;
	import org.apache.atlas.bulkimport.BulkImportResponse;
	import org.apache.atlas.model.glossary.AtlasGlossary;
	import org.apache.atlas.model.glossary.AtlasGlossaryCategory;
	import org.apache.atlas.model.glossary.AtlasGlossaryTerm;
	import org.apache.atlas.model.glossary.enums.AtlasTermRelationshipStatus;
	import org.apache.atlas.model.glossary.relations.AtlasGlossaryHeader;
	import org.apache.atlas.model.glossary.relations.AtlasRelatedCategoryHeader;
	import org.apache.atlas.model.glossary.relations.AtlasRelatedTermHeader;
	import org.apache.atlas.model.instance.AtlasEntity;
	import org.apache.atlas.model.instance.AtlasEntityHeader;
	import org.apache.atlas.model.instance.AtlasRelatedObjectId;
	import org.apache.atlas.model.typedef.AtlasTypesDef;
	import org.apache.atlas.type.AtlasType;
	import org.apache.atlas.utils.AuthenticationUtil;
	import org.apache.atlas.utils.TestResourceFileUtils;
	import org.apache.atlas.web.TestUtils;
	import org.apache.commons.io.FileUtils;
	import org.apache.commons.lang.RandomStringUtils;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;
	import org.testng.annotations.AfterClass;
	import org.testng.annotations.BeforeClass;
	import org.testng.annotations.Test;

	import java.io.File;
	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import static org.testng.Assert.assertEquals;
	import static org.testng.Assert.assertNotNull;
	import static org.testng.Assert.assertNull;
	import static org.testng.Assert.fail;

	public class GlossaryClientV2IT extends BaseResourceIT {
	private static final Logger LOG = LoggerFactory.getLogger(GlossaryClientV2IT.class);
	private static final ObjectMapper mapper = new ObjectMapper();

	private AtlasTypesDef typeDefinitions;
	private AtlasClientV2 clientV2;
	private AtlasGlossary educationGlossary, healthCareGlossary;
	private AtlasGlossaryTerm educationTerm, schoolEducationTerm;
	private AtlasGlossaryCategory educationCategory;
	private List<AtlasRelatedObjectId> relatedObjectIds;
	private AtlasEntityHeader entityHeader;

	@BeforeClass
	public void setUp() throws Exception {
	super.setUp();
	typeDefinitions = setForGlossary();
	createType(typeDefinitions);

	if (!AuthenticationUtil.isKerberosAuthenticationEnabled()) {
	clientV2 = new AtlasClientV2(atlasUrls, new String[]{"admin", "admin"});
	} else {
	clientV2 = new AtlasClientV2(atlasUrls);
	}
	}

	@AfterClass
	public void tearDown() throws Exception {
	emptyTypeDefs(typeDefinitions);
	}

	@Test
	public void testCreateGlossary() throws Exception {
	educationGlossary = createAndGetGlossary("Education");
	assertNotNull(educationGlossary);
	}

	@Test(dependsOnMethods = "testCreateGlossary")
	public void testGetGlossaryByGuid() throws Exception {
	healthCareGlossary = createAndGetGlossary("HealthCare");
	AtlasGlossary atlasGlossaryByGuid = atlasClientV2.getGlossaryByGuid(healthCareGlossary.getGuid());
	assertNotNull(atlasGlossaryByGuid);
	assertEquals(healthCareGlossary.getGuid(), atlasGlossaryByGuid.getGuid());
	}

	@Test(dependsOnMethods = "testCreateGlossary")
	public void testGetDetailGlossary() throws Exception {
	AtlasGlossary.AtlasGlossaryExtInfo extInfo = atlasClientV2.getGlossaryExtInfo(educationGlossary.getGuid());
	assertNotNull(extInfo);
	assertEquals(educationGlossary.getGuid(), extInfo.getGuid());
	}

	@Test(dependsOnMethods = "testGetGlossaryByGuid")
	public void getAllGlossary() throws Exception {
	List<AtlasGlossary> list = atlasClientV2.getAllGlossaries("ASC", 5, 0);
	assertNotNull(list);
	assertEquals(list.size(), 3);
	}

	@Test(dependsOnMethods = "testCreateGlossary")
	public void updateGlossaryByGuid() throws Exception {
	AtlasGlossary newGlossary = new AtlasGlossary();
	newGlossary.setLanguage("English");
	newGlossary.setName("updateGlossary");
	AtlasGlossary updated = atlasClientV2.updateGlossaryByGuid(educationGlossary.getGuid(), newGlossary);
	assertNotNull(updated);
	assertEquals(updated.getGuid(), educationGlossary.getGuid());
	assertEquals(updated.getLanguage(), newGlossary.getLanguage());
	}

	@Test(dependsOnMethods = "testCreateGlossary")
	public void testCreateTerm() throws Exception {
	AtlasGlossaryTerm term = new AtlasGlossaryTerm();
	AtlasGlossaryHeader header = new AtlasGlossaryHeader();
	header.setGlossaryGuid(educationGlossary.getGuid());
	header.setDisplayText(educationGlossary.getName());
	term.setAnchor(header);
	term.setName("termForEducation");
	educationTerm = atlasClientV2.createGlossaryTerm(term);
	assertNotNull(educationTerm);
	assertNotNull(educationTerm.getGuid());
	}

	@Test(dependsOnMethods = "testCreateTerm")
	public void testGetGlossaryTerm() throws Exception {
	AtlasGlossaryTerm term = atlasClientV2.getGlossaryTerm(educationTerm.getGuid());
	assertNotNull(term);
	assertEquals(term.getGuid(), educationTerm.getGuid());
	}

	@Test(dependsOnMethods = "testCreateTerm")
	public void testGetGlossaryTerms() throws Exception {
	AtlasRelatedTermHeader relatedTermHeader = new AtlasRelatedTermHeader();
	relatedTermHeader.setTermGuid(educationTerm.getGuid());
	relatedTermHeader.setDescription("test description");
	relatedTermHeader.setExpression("test expression");
	relatedTermHeader.setSource("School");
	relatedTermHeader.setSteward("School");
	relatedTermHeader.setStatus(AtlasTermRelationshipStatus.ACTIVE);
	schoolEducationTerm = new AtlasGlossaryTerm();
	AtlasGlossaryHeader header = new AtlasGlossaryHeader();
	header.setGlossaryGuid(educationGlossary.getGuid());
	header.setDisplayText(educationGlossary.getName());
	schoolEducationTerm.setAnchor(header);
	schoolEducationTerm.setName("termForSchool");
	schoolEducationTerm.setSeeAlso(Collections.singleton(relatedTermHeader));

	schoolEducationTerm = clientV2.createGlossaryTerm(schoolEducationTerm);
	assertNotNull(schoolEducationTerm);
	assertNotNull(schoolEducationTerm.getGuid());

	//Getting multiple terms
	List<AtlasGlossaryTerm> terms = atlasClientV2.getGlossaryTerms(educationGlossary.getGuid(), "ASC", 2, 0);
	assertNotNull(terms);
	assertEquals(terms.size(), 2);
	}

	@Test(dependsOnMethods = "testCreateGlossary")
	public void testCreateGlossaryCategory() throws Exception {
	AtlasGlossaryCategory category = new AtlasGlossaryCategory();
	AtlasGlossaryHeader header = new AtlasGlossaryHeader();
	header.setGlossaryGuid(educationGlossary.getGuid());
	header.setDisplayText(educationGlossary.getName());
	category.setAnchor(header);
	category.setName("categoryForEducation");
	educationCategory = atlasClientV2.createGlossaryCategory(category);
	assertNotNull(educationCategory);
	assertNotNull(educationCategory.getGuid());
	}

	@Test(dependsOnMethods = "testCreateGlossaryCategory")
	public void testCreateGlossaryCategories() throws Exception {
	List<AtlasGlossaryCategory> glossaryCategories = new ArrayList<>();

	AtlasGlossaryCategory category1 = new AtlasGlossaryCategory();
	AtlasGlossaryHeader header1 = new AtlasGlossaryHeader();
	header1.setGlossaryGuid(healthCareGlossary.getGuid());
	header1.setDisplayText(healthCareGlossary.getName());
	category1.setAnchor(header1);
	category1.setName("category1ForEducation");
	glossaryCategories.add(category1);
	//Setting different category
	AtlasGlossaryCategory category2 = new AtlasGlossaryCategory();
	category2.setAnchor(header1);
	category2.setName("category2ForEducation");
	glossaryCategories.add(category2);

	List<AtlasGlossaryCategory> list = atlasClientV2.createGlossaryCategories(glossaryCategories);
	assertNotNull(list);
	assertEquals(list.size(), 2);
	}

	@Test(dependsOnMethods = "testCreateGlossaryCategory")
	public void testGetGlossaryByCategory() throws Exception {
	AtlasGlossaryCategory atlasGlossaryCategory = atlasClientV2.getGlossaryCategory(educationCategory.getGuid());
	assertNotNull(atlasGlossaryCategory);
	assertEquals(atlasGlossaryCategory.getGuid(), educationCategory.getGuid());
	}

	@Test(dependsOnMethods = "testGetGlossaryByGuid")
	public void testCreateGlossaryTerms() throws Exception {
	List<AtlasGlossaryTerm> list = new ArrayList<>();
	int index = 0;
	List<AtlasGlossary> glossaries = atlasClientV2.getAllGlossaries("ASC", 5, 0);
	List<AtlasGlossary> glossaryList = mapper.convertValue(
	glossaries,
	new TypeReference<List<AtlasGlossary>>() {
	});

	for (AtlasGlossary glossary : glossaryList) {
	AtlasGlossaryTerm term = new AtlasGlossaryTerm();
	AtlasGlossaryHeader header = new AtlasGlossaryHeader();
	header.setGlossaryGuid(glossary.getGuid());
	header.setDisplayText(glossary.getName());
	term.setAnchor(header);
	term.setName("termName" + index);
	list.add(term);
	index++;
	}
	List<AtlasGlossaryTerm> termList = atlasClientV2.createGlossaryTerms(list);
	assertNotNull(termList);
	assertEquals(termList.size(), 3);
	}

	@Test(dependsOnMethods = "testCreateGlossary")
	public void testPartialUpdateGlossaryByGuid() throws Exception {
	Map<String, String> partialUpdates = new HashMap<>();
	partialUpdates.put("shortDescription", "shortDescription");
	partialUpdates.put("longDescription", "longDescription");
	AtlasGlossary atlasGlossary = atlasClientV2.partialUpdateGlossaryByGuid(educationGlossary.getGuid(), partialUpdates);
	assertNotNull(atlasGlossary);
	assertEquals(atlasGlossary.getShortDescription(), "shortDescription");
	assertEquals(atlasGlossary.getLongDescription(), "longDescription");
	}

	@Test(dependsOnMethods = "testCreateGlossary")
	public void testUpdateGlossaryTermByGuid() throws Exception {
	AtlasGlossaryTerm term = new AtlasGlossaryTerm(educationTerm);
	term.setAbbreviation("trm");
	AtlasGlossaryTerm responseTerm = atlasClientV2.updateGlossaryTermByGuid(educationTerm.getGuid(), term);
	assertNotNull(responseTerm);
	assertEquals(responseTerm.getAbbreviation(), term.getAbbreviation());
	}

	@Test(dependsOnMethods = "testCreateGlossary")
	public void testUpdateGlossaryCategoryByGuid() throws Exception {
	AtlasGlossaryCategory category = new AtlasGlossaryCategory(educationCategory);
	category.setLongDescription("this is about category");
	AtlasGlossaryCategory responseCategory = atlasClientV2.updateGlossaryCategoryByGuid(educationCategory.getGuid(), category);
	assertNotNull(responseCategory);
	assertEquals(responseCategory.getLongDescription(), category.getLongDescription());
	}

	@Test(dependsOnMethods = "testCreateGlossary")
	public void testPartialUpdateTermByGuid() throws Exception {
	Map<String, String> partialUpdates = new HashMap<>();
	partialUpdates.put("shortDescription", "shortDescriptionTerm");
	partialUpdates.put("longDescription", "longDescriptionTerm");

	AtlasGlossaryTerm term = atlasClientV2.partialUpdateTermByGuid(educationTerm.getGuid(), partialUpdates);
	assertNotNull(term);
	assertEquals(term.getShortDescription(), "shortDescriptionTerm");
	assertEquals(term.getLongDescription(), "longDescriptionTerm");
	}

	@Test(dependsOnMethods = "testCreateGlossary")
	public void testPartialUpdateCategoryByGuid() throws Exception {
	Map<String, String> partialUpdates = new HashMap<>();
	partialUpdates.put("shortDescription", "shortDescriptionCategory");
	partialUpdates.put("longDescription", "longDescriptionCategory");

	AtlasGlossaryCategory category = atlasClientV2.partialUpdateCategoryByGuid(educationCategory.getGuid(), partialUpdates);
	assertNotNull(category);
	assertEquals(category.getShortDescription(), "shortDescriptionCategory");
	assertEquals(category.getLongDescription(), "longDescriptionCategory");
	}

	@Test(dependsOnMethods = "testCreateGlossary")
	public void testGetGlossaryTermHeadersByGuid() throws Exception {
	List<AtlasRelatedTermHeader> list = atlasClientV2.getGlossaryTermHeaders(educationGlossary.getGuid(), "ASC", 2, 0);
	assertNotNull(list);
	assertEquals(list.size(), 1);
	}

	@Test(dependsOnMethods = "testCreateGlossaryCategories")
	public void testGetGlossaryCategoriesByGuid() throws Exception {
	List<AtlasGlossaryCategory> list = atlasClientV2.getGlossaryCategories(healthCareGlossary.getGuid(), "ASC", 2, 0);
	assertNotNull(list);
	assertEquals(list.size(), 2);
	}

	@Test(dependsOnMethods = "testCreateGlossaryCategories")
	public void testGetGlossaryCategoryHeaders() throws Exception {
	List<AtlasRelatedCategoryHeader> list = atlasClientV2.getGlossaryCategoryHeaders(healthCareGlossary.getGuid(), "ASC", 2, 0);
	assertNotNull(list);
	assertEquals(list.size(), 2);
	}

	@Test(dependsOnMethods = "testCreateGlossary")
	public void testGetCategoryTerms() throws Exception {
	List<AtlasRelatedTermHeader> list = atlasClientV2.getCategoryTerms(educationCategory.getGuid(), "ASC", 2, 0);
	assertNotNull(list);
	assertEquals(list.size(), 0);
	}

	@Test(dependsOnMethods = "testCreateGlossary")
	public void testGetAllRelatedTerms() throws Exception {
	Map<AtlasGlossaryTerm.Relation, Set<AtlasRelatedTermHeader>> map = atlasClientV2.getRelatedTerms(educationTerm.getGuid(), "ASC", 2, 0);
	assertNotNull(map);
	}

	@Test(dependsOnMethods = "testCreateTerm")
	public void testAssignTermToEntities() throws Exception {
	try {
	AtlasEntity entity = new AtlasEntity("Asset");
	entity.setAttribute("qualifiedName", "testAsset");
	entity.setAttribute("name", "testAsset");
	if (entityHeader == null) {
	entityHeader = createEntity(entity);
	}
	AtlasRelatedObjectId relatedObjectId = new AtlasRelatedObjectId();
	relatedObjectId.setGuid(entityHeader.getGuid());
	relatedObjectId.setTypeName(entityHeader.getTypeName());
	assertNotNull(relatedObjectId);
	relatedObjectIds = new ArrayList<>();
	relatedObjectIds.add(relatedObjectId);

	atlasClientV2.assignTermToEntities(educationTerm.getGuid(), relatedObjectIds);
	List<AtlasRelatedObjectId> assignedEntities = atlasClientV2.getEntitiesAssignedWithTerm(educationTerm.getGuid(), "ASC", 2, 0);
	assertNotNull(assignedEntities);
	assertEquals(assignedEntities.size(), 1);
	List<AtlasRelatedObjectId> entityList = mapper.convertValue(
	assignedEntities,
	new TypeReference<List<AtlasRelatedObjectId>>() {
	});
	String relationshipGuid = entityList.get(0).getRelationshipGuid();
	assertNotNull(relationshipGuid);
	relatedObjectId.setRelationshipGuid(relationshipGuid);

	} catch (Exception e) {
	e.printStackTrace();
	}

	}

	@Test(dependsOnMethods = "testAssignTermToEntities")
	public void testDisassociateTermAssignmentFromEntities() throws Exception {
	atlasClientV2.disassociateTermFromEntities(educationTerm.getGuid(), relatedObjectIds);
	AtlasGlossaryTerm term = atlasClientV2.getGlossaryTerm(educationTerm.getGuid());
	atlasClientV2.deleteEntityByGuid(entityHeader.getGuid());
	assertNotNull(term);
	assertNull(term.getAssignedEntities());
	}

	@Test(dependsOnMethods = "testCreateGlossaryCategory")
	public void testGetRelatedCategories() throws Exception {
	Map<String, List<AtlasRelatedCategoryHeader>> map = atlasClientV2.getRelatedCategories(educationCategory.getGuid(), "ASC", 1, 0);
	assertEquals(map.size(), 0);
	}

	@Test(dependsOnMethods = "testDeleteGlossaryTerm")
	public void testDeleteGlossary() throws Exception {
	emptyTypeDefs(typeDefinitions);
	atlasClientV2.deleteGlossaryByGuid(educationGlossary.getGuid());
	atlasClientV2.deleteGlossaryByGuid(healthCareGlossary.getGuid());
	try {
	atlasClientV2.getGlossaryByGuid(healthCareGlossary.getGuid());
	} catch (AtlasServiceException ex) {
	assertNotNull(ex.getStatus());
	assertEquals(ex.getStatus(), ClientResponse.Status.NOT_FOUND);
	}
	try {
	atlasClientV2.getGlossaryByGuid(educationGlossary.getGuid());
	} catch (AtlasServiceException ex) {
	assertNotNull(ex.getStatus());
	assertEquals(ex.getStatus(), ClientResponse.Status.NOT_FOUND);
	}
	}

	@Test(dependsOnMethods = "testDisassociateTermAssignmentFromEntities")
	public void testDeleteGlossaryTerm() throws Exception {
	atlasClientV2.deleteGlossaryTermByGuid(educationTerm.getGuid());
	try {
	atlasClientV2.getGlossaryTerm(educationTerm.getGuid());
	} catch (AtlasServiceException ex) {
	assertNotNull(ex.getStatus());
	assertEquals(ex.getStatus(), ClientResponse.Status.NOT_FOUND);
	}
	}

	@Test(dependsOnMethods = "testGetRelatedCategories")
	public void testDeleteGlossaryCategory() throws Exception {
	atlasClientV2.deleteGlossaryCategoryByGuid(educationCategory.getGuid());
	try {
	atlasClientV2.getGlossaryCategory(educationCategory.getGuid());
	} catch (AtlasServiceException ex) {
	assertNotNull(ex.getStatus());
	assertEquals(ex.getStatus(), ClientResponse.Status.NOT_FOUND);
	}
	}

	@Test()
	public void testProduceTemplate() {
	try {
	String template = atlasClientV2.getGlossaryImportTemplate();

	assertNotNull(template);
	} catch (AtlasServiceException ex) {
	fail("Deletion should've succeeded");
	}
	}

	@Test()
	public void testImportGlossaryData() {
	try {
	String filePath = TestResourceFileUtils.getTestFilePath("template.csv");
	BulkImportResponse terms = atlasClientV2.importGlossary(filePath);

	assertNotNull(terms);

	assertEquals(terms.getSuccessImportInfoList().size(), 1);

	} catch (AtlasServiceException ex) {
	fail("Import GlossaryData should've succeeded : "+ex);
	}
	}

	private AtlasGlossary createAndGetGlossary(String name) throws Exception {
	AtlasGlossary atlasGlossary = new AtlasGlossary();
	atlasGlossary.setName(name);
	return atlasClientV2.createGlossary(atlasGlossary);
	}

	private void emptyTypeDefs(AtlasTypesDef def) {
	def.getEnumDefs().clear();
	def.getStructDefs().clear();
	def.getClassificationDefs().clear();
	def.getEntityDefs().clear();
	def.getRelationshipDefs().clear();
	def.getBusinessMetadataDefs().clear();
	}

	private AtlasTypesDef setForGlossary() throws IOException {
	String filePath = TestUtils.getGlossaryType();
	String json = FileUtils.readFileToString(new File(filePath));
	return AtlasType.fromJson(json, AtlasTypesDef.class);
	}

	protected String randomString() {
	//names cannot start with a digit
	return RandomStringUtils.randomAlphabetic(1) + RandomStringUtils.randomAlphanumeric(9);
	}

	}