Java tutorial
/** * 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 * * http://www.apache.org/licenses/LICENSE-2.0 * * 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.falcon.regression.lineage; import org.apache.commons.httpclient.HttpStatus; import org.apache.falcon.regression.Entities.ClusterMerlin; import org.apache.falcon.regression.Entities.FeedMerlin; import org.apache.falcon.regression.core.bundle.Bundle; import org.apache.falcon.entity.v0.feed.LocationType; import org.apache.falcon.regression.core.enumsAndConstants.MerlinConstants; import org.apache.falcon.regression.core.helpers.ColoHelper; import org.apache.falcon.regression.core.helpers.LineageHelper; import org.apache.falcon.regression.core.response.lineage.Direction; import org.apache.falcon.regression.core.response.lineage.Edge; import org.apache.falcon.regression.core.response.lineage.EdgesResult; import org.apache.falcon.regression.core.response.lineage.Vertex; import org.apache.falcon.regression.core.response.lineage.VertexIdsResult; import org.apache.falcon.regression.core.response.lineage.VertexResult; import org.apache.falcon.regression.core.response.lineage.VerticesResult; import org.apache.falcon.regression.core.util.AssertUtil; import org.apache.falcon.regression.core.util.BundleUtil; import org.apache.falcon.regression.core.util.Generator; import org.apache.falcon.regression.core.util.GraphAssert; import org.apache.falcon.regression.core.util.Util; import org.apache.falcon.regression.testHelper.BaseTestClass; import org.apache.http.HttpResponse; import org.apache.log4j.Logger; import org.testng.Assert; import org.testng.annotations.AfterMethod; import org.testng.annotations.BeforeClass; import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; import java.util.List; import java.util.Map; import java.util.Random; import java.util.TreeMap; /** * Tests for Lineage API. */ @Test(groups = "lineage-rest") public class LineageApiTest extends BaseTestClass { private static final Logger LOGGER = Logger.getLogger(LineageApiTest.class); private static final String TEST_NAME = "LineageApiTest"; private static final String TEST_TAG = Edge.LabelType.TESTNAME.toString().toLowerCase() + "=" + TEST_NAME; private static final String VERTEX_NOT_FOUND_REGEX = ".*Vertex.*%d.*not.*found.*\n?"; private static final String INVALID_ARGUMENT_STR = "Invalid argument"; private LineageHelper lineageHelper; private final ColoHelper cluster = servers.get(0); private final String baseTestHDFSDir = cleanAndGetTestDir(); private final String feedInputPath = baseTestHDFSDir + "/input"; private final String feedOutputPath = baseTestHDFSDir + "/output"; // use 5 <= x < 10 input feeds private final int numInputFeeds = 5 + new Random().nextInt(5); // use 5 <= x < 10 output feeds private final int numOutputFeeds = 5 + new Random().nextInt(5); private ClusterMerlin clusterMerlin; private FeedMerlin[] inputFeeds; private FeedMerlin[] outputFeeds; @BeforeClass(alwaysRun = true) public void init() { lineageHelper = new LineageHelper(prism); } @BeforeMethod(alwaysRun = true, firstTimeOnly = true) public void setUp() throws Exception { Bundle bundle = BundleUtil.readELBundle(); bundle.generateUniqueBundle(this); bundles[0] = new Bundle(bundle, cluster); final List<String> clusterStrings = bundles[0].getClusters(); Assert.assertEquals(clusterStrings.size(), 1, "Expecting only 1 clusterMerlin."); clusterMerlin = new ClusterMerlin(clusterStrings.get(0)); clusterMerlin.setTags(TEST_TAG); AssertUtil.assertSucceeded(prism.getClusterHelper().submitEntity(clusterMerlin.toString())); LOGGER.info("numInputFeeds = " + numInputFeeds); LOGGER.info("numOutputFeeds = " + numOutputFeeds); final FeedMerlin inputMerlin = new FeedMerlin(bundles[0].getInputFeedFromBundle()); inputMerlin.setTags(TEST_TAG); String namePrefix = Util.getEntityPrefix(this) + '-'; inputFeeds = generateFeeds(numInputFeeds, inputMerlin, Generator.getNameGenerator(namePrefix + "infeed", inputMerlin.getName().replace(namePrefix, "")), Generator.getHadoopPathGenerator(feedInputPath, MINUTE_DATE_PATTERN)); for (FeedMerlin feed : inputFeeds) { AssertUtil.assertSucceeded(prism.getFeedHelper().submitEntity(feed.toString())); } FeedMerlin outputMerlin = new FeedMerlin(bundles[0].getOutputFeedFromBundle()); outputMerlin.setTags(TEST_TAG); outputFeeds = generateFeeds(numOutputFeeds, outputMerlin, Generator.getNameGenerator(namePrefix + "outfeed", outputMerlin.getName().replace(namePrefix, "")), Generator.getHadoopPathGenerator(feedOutputPath, MINUTE_DATE_PATTERN)); for (FeedMerlin feed : outputFeeds) { AssertUtil.assertSucceeded(prism.getFeedHelper().submitEntity(feed.toString())); } } public static FeedMerlin[] generateFeeds(final int numInputFeeds, final FeedMerlin originalFeedMerlin, final Generator nameGenerator, final Generator pathGenerator) { FeedMerlin[] inputFeeds = new FeedMerlin[numInputFeeds]; //submit all input feeds for (int count = 0; count < numInputFeeds; ++count) { final FeedMerlin feed = new FeedMerlin(originalFeedMerlin.toString()); feed.setName(nameGenerator.generate()); feed.setLocation(LocationType.DATA, pathGenerator.generate()); inputFeeds[count] = feed; } return inputFeeds; } @AfterMethod(alwaysRun = true, lastTimeOnly = true) public void tearDown() { removeTestClassEntities(); } /** * Get all vertices from falcon and check that they are sane. * @throws Exception */ @Test public void testAllVertices() throws Exception { final VerticesResult verticesResult = lineageHelper.getAllVertices(); LOGGER.info(verticesResult); GraphAssert.assertVertexSanity(verticesResult); GraphAssert.assertUserVertexPresence(verticesResult); GraphAssert.assertVerticesPresenceMinOccur(verticesResult, Vertex.VERTEX_TYPE.COLO, 1); GraphAssert.assertVerticesPresenceMinOccur(verticesResult, Vertex.VERTEX_TYPE.TAGS, 1); GraphAssert.assertVerticesPresenceMinOccur(verticesResult, Vertex.VERTEX_TYPE.CLUSTER_ENTITY, 1); GraphAssert.assertVerticesPresenceMinOccur(verticesResult, Vertex.VERTEX_TYPE.FEED_ENTITY, numInputFeeds + numOutputFeeds); } /** * Get a vertex by id and check results. * @throws Exception */ @Test public void testVertexId() throws Exception { final VerticesResult userResult = lineageHelper.getVerticesByName(MerlinConstants.CURRENT_USER_NAME); GraphAssert.assertVertexSanity(userResult); final int vertexId = userResult.getResults().get(0).getId(); final VertexResult userVertex = lineageHelper.getVertexById(vertexId); Assert.assertEquals(userResult.getResults().get(0), userVertex.getResults(), "Same vertex should have been returned."); } /** * Negative test - get a vertex without specifying id, we should not get internal server error. * @throws Exception */ @Test public void testVertexNoId() throws Exception { HttpResponse response = lineageHelper.runGetRequest(lineageHelper.getUrl(LineageHelper.URL.VERTICES, "")); String responseString = lineageHelper.getResponseString(response); LOGGER.info("response: " + response); LOGGER.info("responseString: " + responseString); Assert.assertNotEquals(response.getStatusLine().getStatusCode(), HttpStatus.SC_INTERNAL_SERVER_ERROR, "We should not get internal server error"); } /** * Negative test - get a vertex specifying an invalid id, we should not get http non-found * error. * @throws Exception */ @Test public void testVertexInvalidId() throws Exception { final VerticesResult allVerticesResult = lineageHelper.getAllVertices(); GraphAssert.assertVertexSanity(allVerticesResult); int invalidVertexId = -1; for (Vertex vertex : allVerticesResult.getResults()) { if (invalidVertexId <= vertex.getId()) { invalidVertexId = vertex.getId() + 1; } } HttpResponse response = lineageHelper .runGetRequest(lineageHelper.getUrl(LineageHelper.URL.VERTICES, "" + invalidVertexId)); String responseString = lineageHelper.getResponseString(response); LOGGER.info("response: " + response); LOGGER.info("responseString: " + responseString); Assert.assertTrue(responseString.matches(String.format(VERTEX_NOT_FOUND_REGEX, invalidVertexId)), "Unexpected responseString: " + responseString); Assert.assertEquals(response.getStatusLine().getStatusCode(), HttpStatus.SC_NOT_FOUND, "We should get http not found error"); } /** * Get properties of one type of vertex and check those properties. * @param vertexType type of the vertex that we want to check */ private void checkVertexOneProperty(Vertex.VERTEX_TYPE vertexType) { final VerticesResult coloResult = lineageHelper.getVerticesByType(vertexType); GraphAssert.assertVertexSanity(coloResult); for (Vertex coloVertex : coloResult.getResults()) { final int coloVertexId = coloVertex.getId(); final VertexResult coloProperties = lineageHelper.getVertexProperties(coloVertexId); Assert.assertNotNull(coloProperties.getResults().getName(), "name should not be null"); Assert.assertEquals(coloProperties.getResults().getType(), vertexType); Assert.assertNotNull(coloProperties.getResults().getTimestamp(), "timestamp should not be null"); } } /** * Test vertex properties for different types of vertices. * @throws Exception */ @Test public void testVertexProperties() throws Exception { //testing properties of a user vertex checkVertexOneProperty(Vertex.VERTEX_TYPE.USER); //testing properties of colo vertices checkVertexOneProperty(Vertex.VERTEX_TYPE.COLO); //testing properties of group vertices checkVertexOneProperty(Vertex.VERTEX_TYPE.GROUPS); //testing properties of group vertices //checkVertexOneProperty(Vertex.VERTEX_TYPE.FEED_ENTITY); } /** * Test vertex properties supplying a blank id, expecting http not found error. * @throws Exception */ @Test public void testVertexPropertiesNoId() throws Exception { //testing properties of a user vertex HttpResponse response = lineageHelper.runGetRequest( lineageHelper.getUrl(LineageHelper.URL.VERTICES_PROPERTIES, lineageHelper.getUrlPath(""))); String responseString = lineageHelper.getResponseString(response); LOGGER.info("response: " + response); LOGGER.info("responseString: " + responseString); Assert.assertEquals(response.getStatusLine().getStatusCode(), HttpStatus.SC_NOT_FOUND, "We should get http not found error"); } /** * Test vertex properties supplying an invalid id, expecting http not found error. * @throws Exception */ @Test public void testVertexPropertiesInvalidId() throws Exception { final VerticesResult allVerticesResult = lineageHelper.getAllVertices(); GraphAssert.assertVertexSanity(allVerticesResult); int invalidVertexId = -1; for (Vertex vertex : allVerticesResult.getResults()) { if (invalidVertexId <= vertex.getId()) { invalidVertexId = vertex.getId() + 1; } } HttpResponse response = lineageHelper .runGetRequest(lineageHelper.getUrl(LineageHelper.URL.VERTICES_PROPERTIES, "" + invalidVertexId)); String responseString = lineageHelper.getResponseString(response); LOGGER.info("response: " + response); LOGGER.info("responseString: " + responseString); Assert.assertTrue(responseString.matches(String.format(VERTEX_NOT_FOUND_REGEX, invalidVertexId)), "Unexpected responseString: " + responseString); Assert.assertEquals(response.getStatusLine().getStatusCode(), HttpStatus.SC_NOT_FOUND, "We should get http not found error"); } /** * Test filtering vertices by name. * @throws Exception */ @Test public void testVerticesFilterByName() throws Exception { final String clusterName = clusterMerlin.getName(); final VerticesResult clusterVertices = lineageHelper.getVerticesByName(clusterName); GraphAssert.assertVertexSanity(clusterVertices); GraphAssert.assertVerticesPresenceMinOccur(clusterVertices, Vertex.VERTEX_TYPE.CLUSTER_ENTITY, 1); GraphAssert.assertVertexPresence(clusterVertices, clusterName); for (int i = 0; i < numInputFeeds; ++i) { final String feedName = inputFeeds[i].getName(); final VerticesResult feedVertices = lineageHelper.getVerticesByName(feedName); GraphAssert.assertVertexSanity(feedVertices); GraphAssert.assertVerticesPresenceMinOccur(feedVertices, Vertex.VERTEX_TYPE.FEED_ENTITY, 1); GraphAssert.assertVertexPresence(feedVertices, feedName); } for (int i = 0; i < numOutputFeeds; ++i) { final String feedName = outputFeeds[i].getName(); final VerticesResult feedVertices = lineageHelper.getVerticesByName(feedName); GraphAssert.assertVertexSanity(feedVertices); GraphAssert.assertVerticesPresenceMinOccur(feedVertices, Vertex.VERTEX_TYPE.FEED_ENTITY, 1); GraphAssert.assertVertexPresence(feedVertices, feedName); } } /** * Test filtering vertices by type. * @throws Exception */ @Test public void testVerticesFilterByType() throws Exception { final VerticesResult clusterVertices = lineageHelper.getVerticesByType(Vertex.VERTEX_TYPE.CLUSTER_ENTITY); GraphAssert.assertVertexSanity(clusterVertices); GraphAssert.assertVerticesPresenceMinOccur(clusterVertices, Vertex.VERTEX_TYPE.CLUSTER_ENTITY, 1); GraphAssert.assertVertexPresence(clusterVertices, clusterMerlin.getName()); final VerticesResult feedVertices = lineageHelper.getVerticesByType(Vertex.VERTEX_TYPE.FEED_ENTITY); GraphAssert.assertVertexSanity(feedVertices); GraphAssert.assertVerticesPresenceMinOccur(feedVertices, Vertex.VERTEX_TYPE.FEED_ENTITY, 1); for (FeedMerlin oneFeed : inputFeeds) { GraphAssert.assertVertexPresence(feedVertices, oneFeed.getName()); } for (FeedMerlin oneFeed : outputFeeds) { GraphAssert.assertVertexPresence(feedVertices, oneFeed.getName()); } } /** * Test filtering vertices when no output is produced. * @throws Exception */ @Test public void testVerticesFilterNoOutput() throws Exception { final String nonExistingName = "this-is-a-non-existing-name"; final VerticesResult clusterVertices = lineageHelper.getVerticesByName(nonExistingName); GraphAssert.assertVertexSanity(clusterVertices); Assert.assertEquals(clusterVertices.getTotalSize(), 0, "Result should not contain any vertex"); } @Test public void testVerticesFilterBlankValue() throws Exception { Map<String, String> params = new TreeMap<>(); params.put("key", Vertex.FilterKey.name.toString()); params.put("value", ""); HttpResponse response = lineageHelper .runGetRequest(lineageHelper.getUrl(LineageHelper.URL.VERTICES, params)); String responseString = lineageHelper.getResponseString(response); LOGGER.info(responseString); Assert.assertEquals(response.getStatusLine().getStatusCode(), HttpStatus.SC_BAD_REQUEST, "The get request was a bad request"); Assert.assertTrue(responseString.contains(INVALID_ARGUMENT_STR), "Result should contain string Invalid argument"); } @Test public void testVerticesFilterBlankKey() throws Exception { Map<String, String> params = new TreeMap<>(); params.put("key", ""); params.put("value", "someValue"); HttpResponse response = lineageHelper .runGetRequest(lineageHelper.getUrl(LineageHelper.URL.VERTICES, params)); String responseString = lineageHelper.getResponseString(response); LOGGER.info(responseString); Assert.assertEquals(response.getStatusLine().getStatusCode(), HttpStatus.SC_BAD_REQUEST, "The get request was a bad request"); Assert.assertTrue(responseString.contains(INVALID_ARGUMENT_STR), "Result should contain string Invalid argument"); } @Test public void testVertexDirectionFetchEdges() throws Exception { final int clusterVertexId = lineageHelper.getVertex(clusterMerlin.getName()).getId(); final EdgesResult bothEdges = lineageHelper.getEdgesByDirection(clusterVertexId, Direction.bothEdges); GraphAssert.assertEdgeSanity(bothEdges); Assert.assertEquals(bothEdges.filterByType(Edge.LabelType.STORED_IN).size(), inputFeeds.length + outputFeeds.length, "Expecting edge between the cluster and inputFeeds, outputFeeds"); Assert.assertEquals(bothEdges.filterByType(Edge.LabelType.CLUSTER_COLO).size(), 1, "Expecting an edge from the cluster to colo"); Assert.assertEquals(bothEdges.getTotalSize(), inputFeeds.length + outputFeeds.length + 3, "Expecting edge from the cluster to inputFeeds & outputFeeds," + "one between cluster and owner, one between cluster and colo and one between cluster and tags"); final EdgesResult inComingEdges = lineageHelper.getEdgesByDirection(clusterVertexId, Direction.inComingEdges); GraphAssert.assertEdgeSanity(inComingEdges); Assert.assertEquals(inComingEdges.getTotalSize(), inputFeeds.length + outputFeeds.length, "Expecting edge from the cluster to inputFeeds & outputFeeds"); Assert.assertEquals(inComingEdges.filterByType(Edge.LabelType.STORED_IN).size(), inputFeeds.length + outputFeeds.length, "Expecting edge from the cluster to inputFeeds & outputFeeds"); final EdgesResult outGoingEdges = lineageHelper.getEdgesByDirection(clusterVertexId, Direction.outGoingEdges); GraphAssert.assertEdgeSanity(outGoingEdges); Assert.assertEquals(outGoingEdges.filterByType(Edge.LabelType.CLUSTER_COLO).size(), 1, "Expecting an edge from the cluster to colo"); Assert.assertEquals(outGoingEdges.filterByType(Edge.LabelType.TESTNAME).size(), 1, "Expecting an edge from the cluster to classification"); Assert.assertEquals(outGoingEdges.getTotalSize(), 3, "Expecting one edge between cluster and owner, one between cluster and colo and " + "one between cluster and tags"); } @Test public void testVertexCountsFetchVertices() throws Exception { final int clusterVertexId = lineageHelper.getVertex(clusterMerlin.getName()).getId(); final VerticesResult bothVertices = lineageHelper.getVerticesByDirection(clusterVertexId, Direction.bothVertices); GraphAssert.assertVertexSanity(bothVertices); Assert.assertEquals(bothVertices.filterByType(Vertex.VERTEX_TYPE.FEED_ENTITY).size(), inputFeeds.length + outputFeeds.length, "Expecting edge from the cluster to inputFeeds & outputFeeds"); Assert.assertEquals(bothVertices.filterByType(Vertex.VERTEX_TYPE.COLO).size(), 1, "The should be one edge between cluster and colo"); Assert.assertEquals(bothVertices.getTotalSize(), inputFeeds.length + outputFeeds.length + 3, "Expecting edge from the cluster to inputFeeds & outputFeeds, " + "one between cluster and owner, one between cluster and colo and one between cluster and tags"); final VerticesResult inComingVertices = lineageHelper.getVerticesByDirection(clusterVertexId, Direction.inComingVertices); GraphAssert.assertVertexSanity(inComingVertices); Assert.assertEquals(inComingVertices.filterByType(Vertex.VERTEX_TYPE.FEED_ENTITY).size(), inputFeeds.length + outputFeeds.length, "Expecting edge from the cluster to inputFeeds & outputFeeds"); Assert.assertEquals(inComingVertices.getTotalSize(), inputFeeds.length + outputFeeds.length, "Expecting edge from the cluster to inputFeeds & outputFeeds and one " + "between cluster and colo"); final VerticesResult outgoingVertices = lineageHelper.getVerticesByDirection(clusterVertexId, Direction.outgoingVertices); GraphAssert.assertVertexSanity(outgoingVertices); Assert.assertEquals(outgoingVertices.filterByType(Vertex.VERTEX_TYPE.COLO).size(), 1, "The should be one edge between cluster and colo"); Assert.assertEquals(outgoingVertices.filterByName(TEST_NAME).size(), 1, "Expecting an edge from the cluster to classification"); Assert.assertEquals(outgoingVertices.getTotalSize(), 3, "Expecting one edge between cluster and owner, one between cluster and colo and " + "one between cluster and tags"); } @Test public void testVertexDirectionFetchCounts() throws Exception { final int clusterVertexId = lineageHelper.getVertex(clusterMerlin.getName()).getId(); final VerticesResult bothCount = lineageHelper.getVerticesByDirection(clusterVertexId, Direction.bothCount); Assert.assertEquals(bothCount.getTotalSize(), inputFeeds.length + outputFeeds.length + 1 + 2, "Expecting edge from the cluster to inputFeeds & outputFeeds, " + "one between cluster and owner, one between cluster and colo and one between cluster and tags"); final VerticesResult inCount = lineageHelper.getVerticesByDirection(clusterVertexId, Direction.inCount); Assert.assertEquals(inCount.getTotalSize(), inputFeeds.length + outputFeeds.length, "Expecting edge from the cluster to inputFeeds & outputFeeds and one " + "between cluster and colo"); final VerticesResult outCount = lineageHelper.getVerticesByDirection(clusterVertexId, Direction.outCount); Assert.assertEquals(outCount.getTotalSize(), 3, "Expecting one edge between cluster and owner, one between cluster and " + "colo and one between cluster and tags"); } @Test public void testVertexDirectionFetchVertexIds() throws Exception { final int clusterVertexId = lineageHelper.getVertex(clusterMerlin.getName()).getId(); final VertexIdsResult bothVerticesIds = lineageHelper.getVertexIdsByDirection(clusterVertexId, Direction.bothVerticesIds); for (Integer vertexId : bothVerticesIds.getResults()) { Assert.assertTrue(vertexId > 0, "Vertex id should be valid."); } Assert.assertEquals(bothVerticesIds.getTotalSize(), inputFeeds.length + outputFeeds.length + 3, "Expecting edge from the cluster to inputFeeds & outputFeeds," + " one between cluster and owner, one between cluster and colo and one between cluster and tags"); final VertexIdsResult incomingVerticesIds = lineageHelper.getVertexIdsByDirection(clusterVertexId, Direction.incomingVerticesIds); for (Integer vertexId : incomingVerticesIds.getResults()) { Assert.assertTrue(vertexId > 0, "Vertex id should be valid."); } Assert.assertEquals(incomingVerticesIds.getTotalSize(), inputFeeds.length + outputFeeds.length, "Expecting edge from the cluster to inputFeeds & outputFeeds, " + "one between cluster and owner, one between cluster and colo and one between cluster and tags"); final VertexIdsResult outgoingVerticesIds = lineageHelper.getVertexIdsByDirection(clusterVertexId, Direction.outgoingVerticesIds); for (Integer vertexId : outgoingVerticesIds.getResults()) { Assert.assertTrue(vertexId > 0, "Vertex id should be valid."); } Assert.assertEquals(outgoingVerticesIds.getTotalSize(), 3, "Expecting one edge between cluster and owner, one between cluster and colo and " + "one between cluster and tags"); } @Test public void testVertexBadDirection() throws Exception { final int clusterVertexId = lineageHelper.getVertex(clusterMerlin.getName()).getId(); HttpResponse response = lineageHelper.runGetRequest(lineageHelper.getUrl(LineageHelper.URL.VERTICES, lineageHelper.getUrlPath(clusterVertexId, "badDirection"))); final String responseString = lineageHelper.getResponseString(response); LOGGER.info("response: " + response); LOGGER.info("responseString: " + responseString); Assert.assertEquals(response.getStatusLine().getStatusCode(), HttpStatus.SC_BAD_REQUEST, "We should not get internal server error"); } @Test public void testAllEdges() throws Exception { final EdgesResult edgesResult = lineageHelper.getAllEdges(); LOGGER.info(edgesResult); Assert.assertTrue(edgesResult.getTotalSize() > 0, "Total number of edges should be" + " greater that zero but is: " + edgesResult.getTotalSize()); GraphAssert.assertEdgeSanity(edgesResult); GraphAssert.assertEdgePresenceMinOccur(edgesResult, Edge.LabelType.CLUSTER_COLO, 1); GraphAssert.assertEdgePresenceMinOccur(edgesResult, Edge.LabelType.STORED_IN, numInputFeeds + numOutputFeeds); GraphAssert.assertEdgePresenceMinOccur(edgesResult, Edge.LabelType.OWNED_BY, 1 + numInputFeeds + numOutputFeeds); } @Test public void testEdge() throws Exception { final int clusterVertexId = lineageHelper.getVertex(clusterMerlin.getName()).getId(); final EdgesResult outGoingEdges = lineageHelper.getEdgesByDirection(clusterVertexId, Direction.outGoingEdges); GraphAssert.assertEdgeSanity(outGoingEdges); Assert.assertEquals(outGoingEdges.filterByType(Edge.LabelType.CLUSTER_COLO).size(), 1, "Expecting an edge from the cluster to colo"); final String clusterColoEdgeId = outGoingEdges.filterByType(Edge.LabelType.CLUSTER_COLO).get(0).getId(); final Edge clusterColoEdge = lineageHelper.getEdgeById(clusterColoEdgeId).getResults(); GraphAssert.assertEdgeSanity(clusterColoEdge); } @Test public void testEdgeBlankId() throws Exception { final HttpResponse httpResponse = lineageHelper .runGetRequest(lineageHelper.getUrl(LineageHelper.URL.EDGES, lineageHelper.getUrlPath(""))); LOGGER.info(httpResponse.toString()); LOGGER.info(lineageHelper.getResponseString(httpResponse)); Assert.assertEquals(httpResponse.getStatusLine().getStatusCode(), HttpStatus.SC_NOT_FOUND, "Expecting not-found error."); } @Test public void testEdgeInvalidId() throws Exception { final HttpResponse response = lineageHelper.runGetRequest( lineageHelper.getUrl(LineageHelper.URL.EDGES, lineageHelper.getUrlPath("invalid-id"))); LOGGER.info(response.toString()); LOGGER.info(lineageHelper.getResponseString(response)); Assert.assertEquals(response.getStatusLine().getStatusCode(), HttpStatus.SC_NOT_FOUND, "Expecting not-found error."); } @Test public void testColoToClusterNode() throws Exception { final VerticesResult verticesResult = lineageHelper.getVerticesByType(Vertex.VERTEX_TYPE.COLO); GraphAssert.assertVertexSanity(verticesResult); Assert.assertTrue(verticesResult.getTotalSize() > 0, "Expected at least 1 colo node"); Assert.assertTrue(verticesResult.getTotalSize() <= 3, "Expected at most 3 colo nodes"); final List<Vertex> colo1Vertex = verticesResult.filterByName(clusterMerlin.getColo()); AssertUtil.checkForListSize(colo1Vertex, 1); Vertex coloVertex = colo1Vertex.get(0); LOGGER.info("coloVertex: " + coloVertex); final VerticesResult verticesByDirection = lineageHelper.getVerticesByDirection(coloVertex.getId(), Direction.inComingVertices); AssertUtil.checkForListSize(verticesByDirection.filterByName(clusterMerlin.getName()), 1); } @Test public void testClusterNodeToFeedNode() throws Exception { final VerticesResult clusterResult = lineageHelper.getVerticesByName(clusterMerlin.getName()); GraphAssert.assertVertexSanity(clusterResult); Vertex clusterVertex = clusterResult.getResults().get(0); final VerticesResult clusterIncoming = lineageHelper.getVerticesByDirection(clusterVertex.getId(), Direction.inComingVertices); GraphAssert.assertVertexSanity(clusterIncoming); for (FeedMerlin feed : inputFeeds) { AssertUtil.checkForListSize(clusterIncoming.filterByName(feed.getName()), 1); } for (FeedMerlin feed : outputFeeds) { AssertUtil.checkForListSize(clusterIncoming.filterByName(feed.getName()), 1); } } @Test public void testUserToEntityNode() throws Exception { final VerticesResult userResult = lineageHelper.getVerticesByName(MerlinConstants.CURRENT_USER_NAME); GraphAssert.assertVertexSanity(userResult); Vertex clusterVertex = userResult.getResults().get(0); final VerticesResult userIncoming = lineageHelper.getVerticesByDirection(clusterVertex.getId(), Direction.inComingVertices); GraphAssert.assertVertexSanity(userIncoming); for (FeedMerlin feed : inputFeeds) { AssertUtil.checkForListSize(userIncoming.filterByName(feed.getName()), 1); } for (FeedMerlin feed : outputFeeds) { AssertUtil.checkForListSize(userIncoming.filterByName(feed.getName()), 1); } } }