org.apache.tinkerpop.gremlin.AbstractGremlinTest Maven / Gradle / Ivy
The newest version!
/*
* 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.tinkerpop.gremlin;
import org.apache.commons.configuration2.Configuration;
import org.apache.tinkerpop.gremlin.process.traversal.Step;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent;
import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
import org.apache.tinkerpop.gremlin.structure.Edge;
import org.apache.tinkerpop.gremlin.structure.Graph;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.apache.tinkerpop.gremlin.structure.VertexProperty;
import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
import org.apache.tinkerpop.gremlin.util.iterator.StoreIteratorCounter;
import org.javatuples.Pair;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.rules.TestName;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertEquals;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.fail;
import static org.junit.Assume.assumeThat;
/**
* Sets up g based on the current graph configuration and checks required features for the test.
*
* @author Stephen Mallette (http://stephen.genoprime.com)
*/
public abstract class AbstractGremlinTest {
private static final Logger logger = LoggerFactory.getLogger(AbstractGremlinTest.class);
protected static final boolean shouldTestIteratorLeak = Boolean.valueOf(System.getProperty("testIteratorLeaks", "true"));
protected Graph graph;
protected GraphTraversalSource g;
protected Configuration config;
protected GraphProvider graphProvider;
@Rule
public TestName name = new TestName();
@Before
public void setup() throws Exception {
final Method testMethod = this.getClass().getMethod(cleanMethodName(name.getMethodName()));
final LoadGraphWith[] loadGraphWiths = testMethod.getAnnotationsByType(LoadGraphWith.class);
final LoadGraphWith loadGraphWith = loadGraphWiths.length == 0 ? null : loadGraphWiths[0];
final LoadGraphWith.GraphData loadGraphWithData = null == loadGraphWith ? null : loadGraphWith.value();
final Set featureRequirementSet = getFeatureRequirementsForTest(testMethod, loadGraphWiths);
graphProvider = GraphManager.getGraphProvider();
// pre-check if available from graph provider to avoid graph creation
final Optional staticFeatures = graphProvider.getStaticFeatures();
if (staticFeatures.isPresent()) {
assumeRequirementsAreMetForTest(featureRequirementSet, staticFeatures.get(), true);
}
graphProvider.getTestListener().ifPresent(l -> l.onTestStart(this.getClass(), name.getMethodName()));
// Reset the counter for open iterators by this test
StoreIteratorCounter.INSTANCE.reset();
config = graphProvider.standardGraphConfiguration(this.getClass(), name.getMethodName(), loadGraphWithData);
// this should clear state from a previously unfinished test. since the graph does not yet exist,
// persisted graphs will likely just have their directories removed
graphProvider.clear(config);
graph = graphProvider.openTestGraph(config);
g = graphProvider.traversal(graph);
// even if we checked static features earlier it's of little cost to recheck again with the real graph
// once it is instantiated. the real cost savings is preventing graph creation in the first place so
// let's double check that all is legit.
assumeRequirementsAreMetForTest(featureRequirementSet, graph.features(), false);
beforeLoadGraphWith(graph);
// load a graph with sample data if the annotation is present on the test
graphProvider.loadGraphData(graph, loadGraphWith, this.getClass(), name.getMethodName());
afterLoadGraphWith(graph);
}
private static void assumeRequirementsAreMetForTest(final Set featureRequirementSet,
final Graph.Features features, final boolean staticCheck)
throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
for (FeatureRequirement fr : featureRequirementSet) {
try {
assumeThat(String.format("Features of the graph do not support all of the features required by this test so it will be ignored: %s.%s=%s",
fr.featureClass().getSimpleName(), fr.feature(), fr.supported()),
features.supports(fr.featureClass(), fr.feature()), is(fr.supported()));
} catch (NoSuchMethodException nsme) {
throw new NoSuchMethodException(String.format("[supports%s] is not a valid feature on %s", fr.feature(), fr.featureClass()));
} catch (UnsupportedOperationException uoe) {
// no worries if this is a check of static features - it just means that we can't use the cache to
// support this check and will have to incur the cost of instantiating a graph instance directly. but,
// if this is not a static check then something else is amiss and we should throw.
if (staticCheck) throw uoe;
}
}
}
protected void beforeLoadGraphWith(final Graph g) throws Exception {
// do nothing
}
protected void afterLoadGraphWith(final Graph g) throws Exception {
// do nothing
}
@After
public void tearDown() throws Exception {
if (null != graphProvider) {
graphProvider.getTestListener().ifPresent(l -> l.onTestEnd(this.getClass(), name.getMethodName()));
// GraphProvider that has implemented the clear method must check null for graph and config.
// If #assumeRequirementsAreMetForTest returns false in #setup, graph and config will be null.
graphProvider.clear(graph, config);
// All GraphProvider objects should be an instance of ManagedGraphProvider, as this is handled by GraphManager
// which wraps injected GraphProviders with a ManagedGraphProvider instance. If this doesn't happen, there
// is no way to trace open graphs.
if(graphProvider instanceof GraphManager.ManagedGraphProvider)
((GraphManager.ManagedGraphProvider)graphProvider).tryClearGraphs();
else
logger.warn("The {} is not of type ManagedGraphProvider and therefore graph instances may leak between test cases.", graphProvider.getClass());
if (shouldTestIteratorLeak) {
final long wait = 300;
final long[] tries = new long[] { 1, 3, 5, 7, 9, 18, 27, 36, 72, 144, 256, 512 };
long openItrCount = StoreIteratorCounter.INSTANCE.getOpenIteratorCount();
for (int ix = 0; ix < tries.length && openItrCount > 0; ix++) {
Thread.sleep(wait * tries[ix]);
openItrCount = StoreIteratorCounter.INSTANCE.getOpenIteratorCount();
}
assertEquals("Iterator leak detected. Open iterator count=" + openItrCount, 0, openItrCount);
}
g = null;
graph = null;
config = null;
graphProvider = null;
}
}
/**
* Looks up the identifier as generated by the current source graph being tested.
*
* @param vertexName a unique string that will identify a graph element within a graph
* @return the id as generated by the graph
*/
public Object convertToVertexId(final String vertexName) {
return convertToVertexId(graph, vertexName);
}
/**
* Looks up the identifier as generated by the current source graph being tested.
*
* @param graph the graph to get the element id from
* @param vertexName a unique string that will identify a graph element within a graph
* @return the id as generated by the graph
*/
public Object convertToVertexId(final Graph graph, final String vertexName) {
return convertToVertex(graph, vertexName).id();
}
public Vertex convertToVertex(final String vertexName) {
return convertToVertex(graph, vertexName);
}
public Vertex convertToVertex(final Graph graph, final String vertexName) {
// all test graphs have "name" as a unique id which makes it easy to hardcode this...works for now
return graphProvider.traversal(graph).V().has("name", vertexName).toList().get(0);
}
public GraphTraversal convertToVertexPropertyId(final String vertexName, final String vertexPropertyKey) {
return convertToVertexPropertyId(graph, vertexName, vertexPropertyKey);
}
public GraphTraversal convertToVertexPropertyId(final Graph graph, final String vertexName, final String vertexPropertyKey) {
return convertToVertexProperty(graph, vertexName, vertexPropertyKey).id();
}
public GraphTraversal> convertToVertexProperty(final Graph graph, final String vertexName, final String vertexPropertyKey) {
// all test graphs have "name" as a unique id which makes it easy to hardcode this...works for now
return (GraphTraversal>) graphProvider.traversal(graph).V().has("name", vertexName).properties(vertexPropertyKey);
}
public VertexProperty convertToVertexProperty(final String vertexName, final String propertyKey, final Object propertyValue) {
return convertToVertexProperty(graph, vertexName, propertyKey).hasValue(propertyValue).toList().get(0);
}
public Edge convertToEdge(final String outVertexName, String edgeLabel, final String inVertexName) {
return convertToEdge(graph, outVertexName, edgeLabel, inVertexName);
}
public Edge convertToEdge(final Graph graph, final String outVertexName, String edgeLabel, final String inVertexName) {
return graphProvider.traversal(graph).V().has("name", outVertexName).outE(edgeLabel).as("e").inV().has("name", inVertexName).select("e").toList().get(0);
}
public Object convertToEdgeId(final String outVertexName, String edgeLabel, final String inVertexName) {
return convertToEdgeId(graph, outVertexName, edgeLabel, inVertexName);
}
public Object convertToEdgeId(final Graph graph, final String outVertexName, String edgeLabel, final String inVertexName) {
return convertToEdge(graph, outVertexName, edgeLabel, inVertexName).id();
}
/**
* Utility method that commits if the graph supports transactions.
*/
public void tryCommit(final Graph graph) {
if (graph.features().graph().supportsTransactions())
graph.tx().commit();
}
/**
* Utility method that commits if the graph supports transactions and executes an assertion function before and
* after the commit. It assumes that the assertion should be true before and after the commit.
*/
public void tryCommit(final Graph graph, final Consumer assertFunction) {
assertFunction.accept(graph);
if (graph.features().graph().supportsTransactions()) {
graph.tx().commit();
assertFunction.accept(graph);
}
}
/**
* Utility method that rollsback if the graph supports transactions.
*/
public void tryRollback(final Graph graph) {
if (graph.features().graph().supportsTransactions())
graph.tx().rollback();
}
/**
* If using "parameterized test" junit will append an identifier to the end of the method name which prevents it
* from being found via reflection. This method removes that suffix.
*/
private static String cleanMethodName(final String methodName) {
if (methodName.endsWith("]")) {
return methodName.substring(0, methodName.indexOf("["));
}
return methodName;
}
public void printTraversalForm(final Traversal traversal) {
logger.info(String.format("Testing: %s", name.getMethodName()));
logger.info(" pre-strategy:" + traversal);
if (!traversal.asAdmin().isLocked()) traversal.asAdmin().applyStrategies();
logger.info(" post-strategy:" + traversal);
verifyUniqueStepIds(traversal.asAdmin());
verifyRootIdentification(traversal.asAdmin(), true);
}
public static void assertVertexEdgeCounts(final Graph graph, final int expectedVertexCount, final int expectedEdgeCount) {
getAssertVertexEdgeCounts(expectedVertexCount, expectedEdgeCount).accept(graph);
}
public static Consumer getAssertVertexEdgeCounts(final int expectedVertexCount, final int expectedEdgeCount) {
return (g) -> {
assertEquals(expectedVertexCount, IteratorUtils.count(g.vertices()));
assertEquals(expectedEdgeCount, IteratorUtils.count(g.edges()));
};
}
public static void validateException(final Throwable expected, final Throwable actual) {
assertThat(actual, instanceOf(expected.getClass()));
}
public static void verifyUniqueStepIds(final Traversal.Admin traversal) {
AbstractGremlinTest.verifyUniqueStepIds(traversal, 0, new HashSet<>());
}
/**
* Ensures that the {@link Traversal} and all of its children is constructed in a fashion where the parent/child
* relationship is properly established.
*/
public static void verifyRootIdentification(final Traversal.Admin traversal, final boolean expectRoot) {
assertThat(traversal.isRoot(), is(expectRoot));
for (final Step step : traversal.getSteps()) {
if (step instanceof TraversalParent) {
for (final Traversal.Admin globalTraversal : ((TraversalParent) step).getGlobalChildren()) {
verifyRootIdentification(globalTraversal, false);
}
for (final Traversal.Admin localTraversal : ((TraversalParent) step).getLocalChildren()) {
verifyRootIdentification(localTraversal, false);
}
}
}
}
private static Set getFeatureRequirementsForTest(final Method testMethod, final LoadGraphWith[] loadGraphWiths) {
// get feature requirements on the test method and add them to the list of ones to check
final FeatureRequirement[] featureRequirement = testMethod.getAnnotationsByType(FeatureRequirement.class);
final List frs = new ArrayList<>(Arrays.asList(featureRequirement));
// if the graph is loading data then it will come with it's own requirements
if (loadGraphWiths.length > 0) frs.addAll(loadGraphWiths[0].value().featuresRequired());
// if the graph has a set of feature requirements bundled together then add those
final FeatureRequirementSet[] featureRequirementSets = testMethod.getAnnotationsByType(FeatureRequirementSet.class);
if (featureRequirementSets.length > 0)
frs.addAll(Arrays.stream(featureRequirementSets)
.flatMap(f -> f.value().featuresRequired().stream()).collect(Collectors.toList()));
// process the unique set of feature requirements
return new HashSet<>(frs);
}
private static void verifyUniqueStepIds(final Traversal.Admin traversal, final int depth, final Set ids) {
for (final Step step : traversal.asAdmin().getSteps()) {
/*for (int i = 0; i < depth; i++) System.out.print("\t");
System.out.println(step.getId() + " --> " + step);*/
if (!ids.add(step.getId())) {
fail("The following step id already exists: " + step.getId() + "---" + step);
}
if (step instanceof TraversalParent) {
for (final Traversal.Admin globalTraversal : ((TraversalParent) step).getGlobalChildren()) {
verifyUniqueStepIds(globalTraversal, depth + 1, ids);
}
for (final Traversal.Admin localTraversal : ((TraversalParent) step).getLocalChildren()) {
verifyUniqueStepIds(localTraversal, depth + 1, ids);
}
}
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy