Skip to content

A
atlas
Commit d661964c by Suma Shivaprasad
Options

ATLAS-858 Unable to delete terms via API which are 3 or more levels deep(jspeidel via sumasai)

parent 9e23fdc1
Showing with 628 additions and 37 deletions
release-log.txt
...@@ -22,6 +22,7 @@ ATLAS-409 Atlas will not import avro tables with schema read from a file (dosset ...@@ -22,6 +22,7 @@ ATLAS-409 Atlas will not import avro tables with schema read from a file (dosset
ATLAS-379 Create sqoop and falcon metadata addons (venkatnrangan,bvellanki,sowmyaramesh via shwethags) ATLAS-379 Create sqoop and falcon metadata addons (venkatnrangan,bvellanki,sowmyaramesh via shwethags)
ALL CHANGES: ALL CHANGES:
ATLAS-858 Unable to delete terms via API which are 3 or more levels deep (jspeidel via sumasai)
ATLAS-848 Atlas UI: Search term box in left navigation is not auto refresh.(Kalyanikashikar via sumasai) ATLAS-848 Atlas UI: Search term box in left navigation is not auto refresh.(Kalyanikashikar via sumasai)
ATLAS-793 Business Catalog Delete (jspeidel via yhemanth) ATLAS-793 Business Catalog Delete (jspeidel via yhemanth)
ATLAS-846 Atlas UI : Add Pagination to Tags and Terms tabs of asset detailes page (kevalbhatt18 via yhemanth) ATLAS-846 Atlas UI : Add Pagination to Tags and Terms tabs of asset detailes page (kevalbhatt18 via yhemanth)
......
webapp/pom.xml
...@@ -297,6 +297,12 @@ ...@@ -297,6 +297,12 @@
<artifactId>atlas-dashboardv2</artifactId> <artifactId>atlas-dashboardv2</artifactId>
<type>war</type> <type>war</type>
</dependency> </dependency>
<dependency>
<groupId>org.easymock</groupId>
<artifactId>easymock</artifactId>
<version>3.4</version>
<scope>test</scope>
</dependency>
</dependencies> </dependencies>
<build> <build>
......
webapp/src/main/java/org/apache/atlas/web/resources/BaseService.java
...@@ -40,6 +40,7 @@ import java.util.Map; ...@@ -40,6 +40,7 @@ import java.util.Map;
public abstract class BaseService { public abstract class BaseService {
private static final Gson gson = new Gson(); private static final Gson gson = new Gson();
private final Logger LOG = LoggerFactory.getLogger(getClass()); private final Logger LOG = LoggerFactory.getLogger(getClass());
private final static JsonSerializer serializer = new JsonSerializer();
protected Result getResource(ResourceProvider provider, Request request) protected Result getResource(ResourceProvider provider, Request request)
throws ResourceNotFoundException { throws ResourceNotFoundException {
...@@ -118,16 +119,20 @@ public abstract class BaseService { ...@@ -118,16 +119,20 @@ public abstract class BaseService {
} }
} }
private RuntimeException wrapRuntimeException(RuntimeException e) { protected JsonSerializer getSerializer() {
return e instanceof CatalogRuntimeException ? e : new CatalogRuntimeException(e); return serializer;
} }
//todo: abstract via AtlasTypeSystem //todo: abstract via AtlasTypeSystem
// ensure that the thread wasn't re-pooled with an existing transaction // ensure that the thread wasn't re-pooled with an existing transaction
private void initializeGraphTransaction() { protected void initializeGraphTransaction() {
TitanGraphProvider.getGraphInstance().rollback(); TitanGraphProvider.getGraphInstance().rollback();
} }
private RuntimeException wrapRuntimeException(RuntimeException e) {
return e instanceof CatalogRuntimeException ? e : new CatalogRuntimeException(e);
}
@XmlRootElement @XmlRootElement
// the name of this class is used as the collection name in the returned json when returning a collection // the name of this class is used as the collection name in the returned json when returning a collection
public static class Results { public static class Results {
......
webapp/src/main/java/org/apache/atlas/web/resources/EntityService.java
...@@ -38,7 +38,6 @@ public class EntityService extends BaseService { ...@@ -38,7 +38,6 @@ public class EntityService extends BaseService {
private final EntityResourceProvider entityResourceProvider; private final EntityResourceProvider entityResourceProvider;
private final EntityTagResourceProvider entityTagResourceProvider; private final EntityTagResourceProvider entityTagResourceProvider;
private static JsonSerializer m_serializer = new JsonSerializer();
@Inject @Inject
public EntityService(MetadataService metadataService) { public EntityService(MetadataService metadataService) {
...@@ -55,7 +54,7 @@ public class EntityService extends BaseService { ...@@ -55,7 +54,7 @@ public class EntityService extends BaseService {
BaseRequest request = new CollectionRequest(Collections.<String, Object>emptyMap(), queryString); BaseRequest request = new CollectionRequest(Collections.<String, Object>emptyMap(), queryString);
Result result = getResources(entityResourceProvider, request); Result result = getResources(entityResourceProvider, request);
return Response.status(Response.Status.OK).entity(m_serializer.serialize(result, ui)).build(); return Response.status(Response.Status.OK).entity(getSerializer().serialize(result, ui)).build();
} }
@GET @GET
...@@ -68,7 +67,7 @@ public class EntityService extends BaseService { ...@@ -68,7 +67,7 @@ public class EntityService extends BaseService {
BaseRequest request = new InstanceRequest(Collections.<String, Object>singletonMap("id", entityId)); BaseRequest request = new InstanceRequest(Collections.<String, Object>singletonMap("id", entityId));
Result result = getResource(entityResourceProvider, request); Result result = getResource(entityResourceProvider, request);
return Response.status(Response.Status.OK).entity(m_serializer.serialize(result, ui)).build(); return Response.status(Response.Status.OK).entity(getSerializer().serialize(result, ui)).build();
} }
@GET @GET
...@@ -84,7 +83,7 @@ public class EntityService extends BaseService { ...@@ -84,7 +83,7 @@ public class EntityService extends BaseService {
properties.put("name", tagName); properties.put("name", tagName);
Result result = getResource(entityTagResourceProvider, new InstanceRequest(properties)); Result result = getResource(entityTagResourceProvider, new InstanceRequest(properties));
return Response.status(Response.Status.OK).entity(m_serializer.serialize(result, ui)).build(); return Response.status(Response.Status.OK).entity(getSerializer().serialize(result, ui)).build();
} }
@GET @GET
...@@ -98,7 +97,7 @@ public class EntityService extends BaseService { ...@@ -98,7 +97,7 @@ public class EntityService extends BaseService {
decode(getQueryString(ui))); decode(getQueryString(ui)));
Result result = getResources(entityTagResourceProvider, request); Result result = getResources(entityTagResourceProvider, request);
return Response.status(Response.Status.OK).entity(m_serializer.serialize(result, ui)).build(); return Response.status(Response.Status.OK).entity(getSerializer().serialize(result, ui)).build();
} }
@POST @POST
......
webapp/src/main/java/org/apache/atlas/web/resources/TaxonomyService.java
...@@ -41,15 +41,14 @@ import java.util.Map; ...@@ -41,15 +41,14 @@ import java.util.Map;
@Singleton @Singleton
public class TaxonomyService extends BaseService { public class TaxonomyService extends BaseService {
private final TaxonomyResourceProvider taxonomyResourceProvider; private ResourceProvider taxonomyResourceProvider;
private static TermResourceProvider termResourceProvider; private ResourceProvider termResourceProvider;
private static JsonSerializer serializer = new JsonSerializer();
@Inject @Inject
public TaxonomyService(MetadataService metadataService) { public void setMetadataService(MetadataService metadataService) {
DefaultTypeSystem typeSystem = new DefaultTypeSystem(metadataService); DefaultTypeSystem typeSystem = new DefaultTypeSystem(metadataService);
taxonomyResourceProvider = new TaxonomyResourceProvider(typeSystem); taxonomyResourceProvider = createTaxonomyResourceProvider(typeSystem);
termResourceProvider = new TermResourceProvider(typeSystem); termResourceProvider = createTermResourceProvider(typeSystem);
} }
@GET @GET
...@@ -62,7 +61,7 @@ public class TaxonomyService extends BaseService { ...@@ -62,7 +61,7 @@ public class TaxonomyService extends BaseService {
Map<String, Object> properties = new HashMap<>(); Map<String, Object> properties = new HashMap<>();
properties.put("name", taxonomyName); properties.put("name", taxonomyName);
Result result = getResource(taxonomyResourceProvider, new InstanceRequest(properties)); Result result = getResource(taxonomyResourceProvider, new InstanceRequest(properties));
return Response.status(Response.Status.OK).entity(serializer.serialize(result, ui)).build(); return Response.status(Response.Status.OK).entity(getSerializer().serialize(result, ui)).build();
} }
@GET @GET
...@@ -71,7 +70,7 @@ public class TaxonomyService extends BaseService { ...@@ -71,7 +70,7 @@ public class TaxonomyService extends BaseService {
String queryString = decode(getQueryString(ui)); String queryString = decode(getQueryString(ui));
Request request = new CollectionRequest(Collections.<String, Object>emptyMap(), queryString); Request request = new CollectionRequest(Collections.<String, Object>emptyMap(), queryString);
Result result = getResources(taxonomyResourceProvider, request); Result result = getResources(taxonomyResourceProvider, request);
return Response.status(Response.Status.OK).entity(serializer.serialize(result, ui)).build(); return Response.status(Response.Status.OK).entity(getSerializer().serialize(result, ui)).build();
} }
@POST @POST
...@@ -120,7 +119,7 @@ public class TaxonomyService extends BaseService { ...@@ -120,7 +119,7 @@ public class TaxonomyService extends BaseService {
properties.put("termPath", termPath); properties.put("termPath", termPath);
Result result = getResource(termResourceProvider, new InstanceRequest(properties)); Result result = getResource(termResourceProvider, new InstanceRequest(properties));
return Response.status(Response.Status.OK).entity(serializer.serialize(result, ui)).build(); return Response.status(Response.Status.OK).entity(getSerializer().serialize(result, ui)).build();
} }
@GET @GET
...@@ -136,7 +135,7 @@ public class TaxonomyService extends BaseService { ...@@ -136,7 +135,7 @@ public class TaxonomyService extends BaseService {
Collections.<String, Object>singletonMap("termPath", termPath), queryString); Collections.<String, Object>singletonMap("termPath", termPath), queryString);
Result result = getResources(termResourceProvider, request); Result result = getResources(termResourceProvider, request);
return Response.status(Response.Status.OK).entity(serializer.serialize(result, ui)).build(); return Response.status(Response.Status.OK).entity(getSerializer().serialize(result, ui)).build();
} }
@GET @GET
...@@ -149,11 +148,6 @@ public class TaxonomyService extends BaseService { ...@@ -149,11 +148,6 @@ public class TaxonomyService extends BaseService {
@PathParam("remainder") String remainder) throws CatalogException { @PathParam("remainder") String remainder) throws CatalogException {
Result result; Result result;
List<PathSegment> pathSegments = ui.getPathSegments();
int lastIndex = pathSegments.size() - 1;
String lastSegment = pathSegments.get(lastIndex).getPath();
String termName = String.format("%s%s", rootTerm, String termName = String.format("%s%s", rootTerm,
remainder.replaceAll("/?terms/?([.]*)", "$1.")); remainder.replaceAll("/?terms/?([.]*)", "$1."));
String queryString = decode(getQueryString(ui)); String queryString = decode(getQueryString(ui));
...@@ -161,13 +155,17 @@ public class TaxonomyService extends BaseService { ...@@ -161,13 +155,17 @@ public class TaxonomyService extends BaseService {
Map<String, Object> properties = new HashMap<>(); Map<String, Object> properties = new HashMap<>();
properties.put("termPath", termPath); properties.put("termPath", termPath);
List<PathSegment> pathSegments = ui.getPathSegments();
int lastIndex = pathSegments.size() - 1;
String lastSegment = pathSegments.get(lastIndex).getPath();
if (lastSegment.equals("terms") || (lastSegment.isEmpty() && pathSegments.get(lastIndex - 1).getPath().equals("terms"))) { if (lastSegment.equals("terms") || (lastSegment.isEmpty() && pathSegments.get(lastIndex - 1).getPath().equals("terms"))) {
result = getResources(termResourceProvider, new CollectionRequest(properties, queryString)); result = getResources(termResourceProvider, new CollectionRequest(properties, queryString));
} else { } else {
result = getResource(termResourceProvider, new InstanceRequest(properties)); result = getResource(termResourceProvider, new InstanceRequest(properties));
} }
return Response.status(Response.Status.OK).entity(serializer.serialize(result, ui)).build(); return Response.status(Response.Status.OK).entity(getSerializer().serialize(result, ui)).build();
} }
@POST @POST
...@@ -188,6 +186,27 @@ public class TaxonomyService extends BaseService { ...@@ -188,6 +186,27 @@ public class TaxonomyService extends BaseService {
new Results(ui.getRequestUri().toString(), 201)).build(); new Results(ui.getRequestUri().toString(), 201)).build();
} }
@POST
@Path("{taxonomyName}/terms/{termName}/{remainder:.*}")
@Produces(Servlets.JSON_MEDIA_TYPE)
public Response createSubTerm(String body,
@Context HttpHeaders headers,
@Context UriInfo ui,
@PathParam("taxonomyName") String taxonomyName,
@PathParam("termName") String termName,
@PathParam("remainder") String remainder) throws CatalogException {
Map<String, Object> properties = parsePayload(body);
String[] pathTokens = remainder.split("/");
validateName(pathTokens[pathTokens.length -1]);
properties.put("termPath", new TermPath(taxonomyName, String.format("%s%s", termName,
remainder.replaceAll("/?terms/?([.]*)", "$1."))));
createResource(termResourceProvider, new InstanceRequest(properties));
return Response.status(Response.Status.CREATED).entity(
new Results(ui.getRequestUri().toString(), 201)).build();
}
@DELETE @DELETE
@Path("{taxonomyName}/terms/{termName}") @Path("{taxonomyName}/terms/{termName}")
@Produces(Servlets.JSON_MEDIA_TYPE) @Produces(Servlets.JSON_MEDIA_TYPE)
...@@ -204,25 +223,30 @@ public class TaxonomyService extends BaseService { ...@@ -204,25 +223,30 @@ public class TaxonomyService extends BaseService {
new Results(ui.getRequestUri().toString(), 200)).build(); new Results(ui.getRequestUri().toString(), 200)).build();
} }
@POST @DELETE
@Path("{taxonomyName}/terms/{termName}/{remainder:.*}") @Path("{taxonomyName}/terms/{termName}/{remainder:.*}")
@Produces(Servlets.JSON_MEDIA_TYPE) @Produces(Servlets.JSON_MEDIA_TYPE)
public Response createSubTerms(String body, public Response deleteSubTerm(@Context HttpHeaders headers,
@Context HttpHeaders headers, @Context UriInfo ui,
@Context UriInfo ui, @PathParam("taxonomyName") String taxonomyName,
@PathParam("taxonomyName") String taxonomyName, @PathParam("termName") String termName,
@PathParam("termName") String termName, @PathParam("remainder") String remainder) throws CatalogException {
@PathParam("remainder") String remainder) throws CatalogException {
Map<String, Object> properties = parsePayload(body); Map<String, Object> properties = new HashMap<>();
String[] pathTokens = remainder.split("/");
validateName(pathTokens[pathTokens.length -1]);
properties.put("termPath", new TermPath(taxonomyName, String.format("%s%s", termName, properties.put("termPath", new TermPath(taxonomyName, String.format("%s%s", termName,
remainder.replaceAll("/?terms/?([.]*)", "$1.")))); remainder.replaceAll("/?terms/?([.]*)", "$1."))));
createResource(termResourceProvider, new InstanceRequest(properties)); deleteResource(termResourceProvider, new InstanceRequest(properties));
return Response.status(Response.Status.CREATED).entity( return Response.status(Response.Status.OK).entity(
new Results(ui.getRequestUri().toString(), 201)).build(); new Results(ui.getRequestUri().toString(), 200)).build();
}
protected ResourceProvider createTaxonomyResourceProvider(AtlasTypeSystem typeSystem) {
return new TaxonomyResourceProvider(typeSystem);
}
protected ResourceProvider createTermResourceProvider(AtlasTypeSystem typeSystem) {
return new TermResourceProvider(typeSystem);
} }
private void validateName(String name) throws InvalidPayloadException { private void validateName(String name) throws InvalidPayloadException {
......
webapp/src/test/java/org/apache/atlas/web/resources/TaxonomyServiceTest.java 0 → 100644
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
* <p/>
* http://www.apache.org/licenses/LICENSE-2.0
* <p/>
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.atlas.web.resources;
import org.apache.atlas.catalog.*;
import org.apache.atlas.services.MetadataService;
import org.easymock.Capture;
import org.testng.annotations.Test;
import static org.easymock.EasyMock.*;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNull;
import static org.testng.Assert.assertTrue;
import javax.ws.rs.core.PathSegment;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriInfo;
import java.net.URI;
import java.util.*;
/**
* Unit tests for TaxonomyService.
*/
public class TaxonomyServiceTest {
@Test
public void testGetTaxonomy() throws Exception {
String taxonomyName = "testTaxonomy";
MetadataService metadataService = createStrictMock(MetadataService.class);
ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
UriInfo uriInfo = createNiceMock(UriInfo.class);
JsonSerializer serializer = createStrictMock(JsonSerializer.class);
Capture<Request> requestCapture = newCapture();
Collection<Map<String, Object>> resultPropertyMaps = new ArrayList<>();
Map<String, Object> propertyMap = new HashMap<>();
propertyMap.put("name", "testTaxonomy");
resultPropertyMaps.add(propertyMap);
Result result = new Result(resultPropertyMaps);
expect(taxonomyResourceProvider.getResourceById(capture(requestCapture))).andReturn(result);
expect(serializer.serialize(result, uriInfo)).andReturn("Taxonomy Get Response");
replay(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
TestTaxonomyService service = new TestTaxonomyService(
metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
Response response = service.getTaxonomy(null, uriInfo, taxonomyName);
assertTrue(service.wasTransactionInitialized());
Request request = requestCapture.getValue();
Map<String, Object> requestProperties = request.getProperties();
assertEquals(requestProperties.size(), 1);
assertEquals(requestProperties.get("name"), taxonomyName);
assertEquals(response.getStatus(), 200);
assertEquals(response.getEntity(), "Taxonomy Get Response");
verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
}
@Test
public void testGetTaxonomies() throws Exception {
MetadataService metadataService = createStrictMock(MetadataService.class);
ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
UriInfo uriInfo = createNiceMock(UriInfo.class);
URI uri = new URI("http://localhost:21000/api/atlas/v1/taxonomies?name:testTaxonomy");
JsonSerializer serializer = createStrictMock(JsonSerializer.class);
Capture<Request> requestCapture = newCapture();
Collection<Map<String, Object>> resultPropertyMaps = new ArrayList<>();
Map<String, Object> propertyMap = new HashMap<>();
propertyMap.put("name", "testTaxonomy");
resultPropertyMaps.add(propertyMap);
Result result = new Result(resultPropertyMaps);
// set mock expectations
expect(uriInfo.getRequestUri()).andReturn(uri);
expect(taxonomyResourceProvider.getResources(capture(requestCapture))).andReturn(result);
expect(serializer.serialize(result, uriInfo)).andReturn("Taxonomy Get Response");
replay(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
// instantiate service and invoke method being tested
TestTaxonomyService service = new TestTaxonomyService(
metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
Response response = service.getTaxonomies(null, uriInfo);
assertTrue(service.wasTransactionInitialized());
Request request = requestCapture.getValue();
assertTrue(request.getProperties().isEmpty());
assertEquals(request.getQueryString(), "name:testTaxonomy");
assertEquals(response.getStatus(), 200);
assertEquals(response.getEntity(), "Taxonomy Get Response");
verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
}
@Test
public void testCreateTaxonomy() throws Exception {
MetadataService metadataService = createStrictMock(MetadataService.class);
ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
UriInfo uriInfo = createNiceMock(UriInfo.class);
URI uri = new URI("http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy");
Capture<Request> requestCapture = newCapture();
String body = "{ \"description\" : \"test description\" } ";
// set mock expectations
expect(uriInfo.getRequestUri()).andReturn(uri);
taxonomyResourceProvider.createResource(capture(requestCapture));
replay(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
// instantiate service and invoke method being tested
TestTaxonomyService service = new TestTaxonomyService(
metadataService, taxonomyResourceProvider, termResourceProvider, null);
Response response = service.createTaxonomy(body, null, uriInfo, "testTaxonomy");
assertTrue(service.wasTransactionInitialized());
Request request = requestCapture.getValue();
assertEquals(request.getProperties().size(), 2);
assertEquals(request.getProperties().get("name"), "testTaxonomy");
assertEquals(request.getProperties().get("description"), "test description");
assertNull(request.getQueryString());
assertEquals(response.getStatus(), 201);
BaseService.Results createResults = (BaseService.Results) response.getEntity();
assertEquals(createResults.href, "http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy");
assertEquals(createResults.status, 201);
verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
}
@Test
public void testDeleteTaxonomy() throws Exception {
MetadataService metadataService = createStrictMock(MetadataService.class);
ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
UriInfo uriInfo = createNiceMock(UriInfo.class);
URI uri = new URI("http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy");
Capture<Request> requestCapture = newCapture();
// set mock expectations
expect(uriInfo.getRequestUri()).andReturn(uri);
taxonomyResourceProvider.deleteResourceById(capture(requestCapture));
replay(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
// instantiate service and invoke method being tested
TestTaxonomyService service = new TestTaxonomyService(
metadataService, taxonomyResourceProvider, termResourceProvider, null);
Response response = service.deleteTaxonomy(null, uriInfo, "testTaxonomy");
assertTrue(service.wasTransactionInitialized());
Request request = requestCapture.getValue();
assertEquals(request.getProperties().size(), 1);
assertEquals(request.getProperties().get("name"), "testTaxonomy");
assertNull(request.getQueryString());
assertEquals(response.getStatus(), 200);
BaseService.Results createResults = (BaseService.Results) response.getEntity();
assertEquals(createResults.href, "http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy");
assertEquals(createResults.status, 200);
verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
}
@Test
public void testGetTaxonomyTerm() throws Exception {
String taxonomyName = "testTaxonomy";
String termName = "testTaxonomy.termName";
MetadataService metadataService = createStrictMock(MetadataService.class);
ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
UriInfo uriInfo = createNiceMock(UriInfo.class);
JsonSerializer serializer = createStrictMock(JsonSerializer.class);
Capture<Request> requestCapture = newCapture();
Collection<Map<String, Object>> resultPropertyMaps = new ArrayList<>();
Map<String, Object> propertyMap = new HashMap<>();
propertyMap.put("name", "testTaxonomy.termName");
resultPropertyMaps.add(propertyMap);
Result result = new Result(resultPropertyMaps);
expect(termResourceProvider.getResourceById(capture(requestCapture))).andReturn(result);
expect(serializer.serialize(result, uriInfo)).andReturn("Taxonomy Term Get Response");
replay(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
TestTaxonomyService service = new TestTaxonomyService(
metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
Response response = service.getTaxonomyTerm(null, uriInfo, taxonomyName, termName);
assertTrue(service.wasTransactionInitialized());
Request request = requestCapture.getValue();
Map<String, Object> requestProperties = request.getProperties();
assertEquals(requestProperties.size(), 1);
TermPath termPath = (TermPath) request.getProperties().get("termPath");
assertEquals(termPath.getFullyQualifiedName(), "testTaxonomy.testTaxonomy.termName");
assertEquals(response.getStatus(), 200);
assertEquals(response.getEntity(), "Taxonomy Term Get Response");
verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
}
@Test
public void testGetTaxonomyTerms() throws Exception {
MetadataService metadataService = createStrictMock(MetadataService.class);
ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
UriInfo uriInfo = createNiceMock(UriInfo.class);
URI uri = new URI("http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy/terms?name:testTaxonomy.testTerm");
JsonSerializer serializer = createStrictMock(JsonSerializer.class);
Capture<Request> requestCapture = newCapture();
Collection<Map<String, Object>> resultPropertyMaps = new ArrayList<>();
Map<String, Object> propertyMap = new HashMap<>();
propertyMap.put("name", "testTaxonomy.testTerm");
resultPropertyMaps.add(propertyMap);
Result result = new Result(resultPropertyMaps);
// set mock expectations
expect(uriInfo.getRequestUri()).andReturn(uri);
expect(termResourceProvider.getResources(capture(requestCapture))).andReturn(result);
expect(serializer.serialize(result, uriInfo)).andReturn("Taxonomy Term Get Response");
replay(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
// instantiate service and invoke method being tested
TestTaxonomyService service = new TestTaxonomyService(
metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
Response response = service.getTaxonomyTerms(null, uriInfo, "testTaxonomy");
assertTrue(service.wasTransactionInitialized());
Request request = requestCapture.getValue();
assertEquals(request.getProperties().size(), 1);
TermPath termPath = (TermPath) request.getProperties().get("termPath");
assertEquals(termPath.getFullyQualifiedName(), "testTaxonomy");
assertEquals(request.getQueryString(), "name:testTaxonomy.testTerm");
assertEquals(response.getStatus(), 200);
assertEquals(response.getEntity(), "Taxonomy Term Get Response");
verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
}
@Test
public void testGetSubTerms_instance() throws Exception {
MetadataService metadataService = createStrictMock(MetadataService.class);
ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
UriInfo uriInfo = createNiceMock(UriInfo.class);
URI uri = new URI("http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy/terms/testTerm/terms/testTerm2");
JsonSerializer serializer = createStrictMock(JsonSerializer.class);
PathSegment segment1 = createNiceMock(PathSegment.class);
PathSegment segment2 = createNiceMock(PathSegment.class);
PathSegment segment3 = createNiceMock(PathSegment.class);
Capture<Request> requestCapture = newCapture();
Collection<Map<String, Object>> resultPropertyMaps = new ArrayList<>();
Map<String, Object> propertyMap = new HashMap<>();
propertyMap.put("name", "testTaxonomy.testTerm.testTerm2");
resultPropertyMaps.add(propertyMap);
Result result = new Result(resultPropertyMaps);
// set mock expectations
expect(uriInfo.getRequestUri()).andReturn(uri);
expect(uriInfo.getPathSegments()).andReturn(Arrays.asList(segment1, segment2, segment3));
expect(segment3.getPath()).andReturn("testTerm2");
expect(termResourceProvider.getResourceById(capture(requestCapture))).andReturn(result);
expect(serializer.serialize(result, uriInfo)).andReturn("Taxonomy Term Get Response");
replay(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer,
segment1, segment2, segment3);
// instantiate service and invoke method being tested
TestTaxonomyService service = new TestTaxonomyService(
metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
Response response = service.getSubTerms(null, uriInfo, "testTaxonomy", "testTerm", "/terms/testTerm2");
assertTrue(service.wasTransactionInitialized());
Request request = requestCapture.getValue();
assertEquals(request.getProperties().size(), 1);
TermPath termPath = (TermPath) request.getProperties().get("termPath");
assertEquals(termPath.getFullyQualifiedName(), "testTaxonomy.testTerm.testTerm2");
assertNull(request.getQueryString());
assertEquals(response.getStatus(), 200);
assertEquals(response.getEntity(), "Taxonomy Term Get Response");
verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer,
segment1, segment2, segment3);
}
@Test
public void testGetSubTerms_collection() throws Exception {
MetadataService metadataService = createStrictMock(MetadataService.class);
ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
UriInfo uriInfo = createNiceMock(UriInfo.class);
URI uri = new URI("http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy/terms/testTerm/terms/testTerm2/terms?name:testTaxonomy.testTerm.testTerm2.testTerm3");
JsonSerializer serializer = createStrictMock(JsonSerializer.class);
// would actually be more segments but at this time only the last segment is used
PathSegment segment1 = createNiceMock(PathSegment.class);
PathSegment segment2 = createNiceMock(PathSegment.class);
PathSegment segment3 = createNiceMock(PathSegment.class);
Capture<Request> requestCapture = newCapture();
Collection<Map<String, Object>> resultPropertyMaps = new ArrayList<>();
Map<String, Object> propertyMap = new HashMap<>();
propertyMap.put("name", "testTaxonomy.testTerm.testTerm2.testTerm3");
resultPropertyMaps.add(propertyMap);
Result result = new Result(resultPropertyMaps);
// set mock expectations
expect(uriInfo.getRequestUri()).andReturn(uri);
expect(uriInfo.getPathSegments()).andReturn(Arrays.asList(segment1, segment2, segment3));
expect(segment3.getPath()).andReturn("terms");
expect(termResourceProvider.getResources(capture(requestCapture))).andReturn(result);
expect(serializer.serialize(result, uriInfo)).andReturn("Taxonomy Term Get Response");
replay(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer,
segment1, segment2, segment3);
// instantiate service and invoke method being tested
TestTaxonomyService service = new TestTaxonomyService(
metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
Response response = service.getSubTerms(null, uriInfo, "testTaxonomy", "testTerm", "/terms/testTerm2/terms");
assertTrue(service.wasTransactionInitialized());
Request request = requestCapture.getValue();
assertEquals(request.getProperties().size(), 1);
TermPath termPath = (TermPath) request.getProperties().get("termPath");
assertEquals(termPath.getFullyQualifiedName(), "testTaxonomy.testTerm.testTerm2.");
assertEquals(request.getQueryString(), "name:testTaxonomy.testTerm.testTerm2.testTerm3");
assertEquals(response.getStatus(), 200);
assertEquals(response.getEntity(), "Taxonomy Term Get Response");
verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer,
segment1, segment2, segment3);
}
@Test
public void testCreateTerm() throws Exception {
String taxonomyName = "testTaxonomy";
String termName = "testTerm";
MetadataService metadataService = createStrictMock(MetadataService.class);
ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
UriInfo uriInfo = createNiceMock(UriInfo.class);
URI uri = new URI("http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy/terms/testTerm");
Capture<Request> requestCapture = newCapture();
String body = "{ \"description\" : \"test description\" } ";
// set mock expectations
expect(uriInfo.getRequestUri()).andReturn(uri);
termResourceProvider.createResource(capture(requestCapture));
replay(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
// instantiate service and invoke method being tested
TestTaxonomyService service = new TestTaxonomyService(
metadataService, taxonomyResourceProvider, termResourceProvider, null);
Response response = service.createTerm(body, null, uriInfo, taxonomyName, termName);
assertTrue(service.wasTransactionInitialized());
Request request = requestCapture.getValue();
assertEquals(request.getProperties().size(), 2);
assertEquals(request.getProperties().get("description"), "test description");
TermPath termPath = (TermPath) request.getProperties().get("termPath");
assertEquals(termPath.getFullyQualifiedName(), "testTaxonomy.testTerm");
assertNull(request.getQueryString());
assertEquals(response.getStatus(), 201);
BaseService.Results createResults = (BaseService.Results) response.getEntity();
assertEquals(createResults.href, "http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy/terms/testTerm");
assertEquals(createResults.status, 201);
verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
}
@Test
public void testCreateSubTerm() throws Exception {
String taxonomyName = "testTaxonomy";
String termName = "testTerm";
MetadataService metadataService = createStrictMock(MetadataService.class);
ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
UriInfo uriInfo = createNiceMock(UriInfo.class);
URI uri = new URI("http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy/terms/testTerm/terms/testTerm2");
Capture<Request> requestCapture = newCapture();
String body = "{ \"description\" : \"test description\" } ";
// set mock expectations
expect(uriInfo.getRequestUri()).andReturn(uri);
termResourceProvider.createResource(capture(requestCapture));
replay(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
// instantiate service and invoke method being tested
TestTaxonomyService service = new TestTaxonomyService(
metadataService, taxonomyResourceProvider, termResourceProvider, null);
Response response = service.createSubTerm(body, null, uriInfo, taxonomyName, termName, "/terms/testTerm2");
assertTrue(service.wasTransactionInitialized());
Request request = requestCapture.getValue();
assertEquals(request.getProperties().size(), 2);
assertEquals(request.getProperties().get("description"), "test description");
TermPath termPath = (TermPath) request.getProperties().get("termPath");
assertEquals(termPath.getFullyQualifiedName(), "testTaxonomy.testTerm.testTerm2");
assertNull(request.getQueryString());
assertEquals(response.getStatus(), 201);
BaseService.Results createResults = (BaseService.Results) response.getEntity();
assertEquals(createResults.href, "http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy/terms/testTerm/terms/testTerm2");
assertEquals(createResults.status, 201);
verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
}
@Test
public void testDeleteTerm() throws Exception {
MetadataService metadataService = createStrictMock(MetadataService.class);
ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
UriInfo uriInfo = createNiceMock(UriInfo.class);
URI uri = new URI("http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy/terms/testTerm");
Capture<Request> requestCapture = newCapture();
// set mock expectations
expect(uriInfo.getRequestUri()).andReturn(uri);
termResourceProvider.deleteResourceById(capture(requestCapture));
replay(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
// instantiate service and invoke method being tested
TestTaxonomyService service = new TestTaxonomyService(
metadataService, taxonomyResourceProvider, termResourceProvider, null);
Response response = service.deleteTerm(null, uriInfo, "testTaxonomy", "testTerm");
assertTrue(service.wasTransactionInitialized());
Request request = requestCapture.getValue();
assertEquals(request.getProperties().size(), 1);
TermPath termPath = (TermPath) request.getProperties().get("termPath");
assertEquals(termPath.getFullyQualifiedName(), "testTaxonomy.testTerm");
assertNull(request.getQueryString());
assertEquals(response.getStatus(), 200);
BaseService.Results createResults = (BaseService.Results) response.getEntity();
assertEquals(createResults.href, "http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy/terms/testTerm");
assertEquals(createResults.status, 200);
verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
}
@Test
public void testDeleteSubTerm() throws Exception {
MetadataService metadataService = createStrictMock(MetadataService.class);
ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
UriInfo uriInfo = createNiceMock(UriInfo.class);
URI uri = new URI("http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy/terms/testTerm/terms/testTerm2");
Capture<Request> requestCapture = newCapture();
// set mock expectations
expect(uriInfo.getRequestUri()).andReturn(uri);
termResourceProvider.deleteResourceById(capture(requestCapture));
replay(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
// instantiate service and invoke method being tested
TestTaxonomyService service = new TestTaxonomyService(
metadataService, taxonomyResourceProvider, termResourceProvider, null);
Response response = service.deleteSubTerm(null, uriInfo, "testTaxonomy", "testTerm", "terms/testTerm2");
assertTrue(service.wasTransactionInitialized());
Request request = requestCapture.getValue();
assertEquals(request.getProperties().size(), 1);
TermPath termPath = (TermPath) request.getProperties().get("termPath");
assertEquals(termPath.getFullyQualifiedName(), "testTaxonomy.testTerm.testTerm2");
assertNull(request.getQueryString());
assertEquals(response.getStatus(), 200);
BaseService.Results createResults = (BaseService.Results) response.getEntity();
assertEquals(createResults.href, "http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy/terms/testTerm/terms/testTerm2");
assertEquals(createResults.status, 200);
verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
}
private static class TestTaxonomyService extends TaxonomyService {
private final ResourceProvider testTaxonomyResourceProvider;
private final ResourceProvider testTermResourceProvider;
private final JsonSerializer testSerializer;
private boolean transactionInitialized = false;
public TestTaxonomyService(MetadataService metadataService,
ResourceProvider taxonomyProvider,
ResourceProvider termResourceProvider,
JsonSerializer serializer) {
testTaxonomyResourceProvider = taxonomyProvider;
testTermResourceProvider = termResourceProvider;
testSerializer = serializer;
setMetadataService(metadataService);
}
@Override
protected ResourceProvider createTaxonomyResourceProvider(AtlasTypeSystem typeSystem) {
return testTaxonomyResourceProvider;
}
@Override
protected ResourceProvider createTermResourceProvider(AtlasTypeSystem typeSystem) {
return testTermResourceProvider;
}
@Override
protected JsonSerializer getSerializer() {
return testSerializer;
}
@Override
protected void initializeGraphTransaction() {
transactionInitialized = true;
}
public boolean wasTransactionInitialized() {
return transactionInitialized;
}
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment