Skip to content

Commit

Permalink
TINKERPOP-2946 Detect ordering issues in Gherkin tests
Browse files Browse the repository at this point in the history
This commit addresses part 1. of TINKERPOP-2946 by introducing
TinkerShuffleGraph and running feature tests against an embedded instance
of this graph.

TinkerShuffleGraph is derived from TinkerGraph and intended for test purposes only.
It's only differentiation from TinkerGraph is that it will returned shuffled results
when getting any of the following:

vertices from the graph,
edges from the graph,
vertices from a vertex,
edges from a vertex,
vertices from an edge,
properties from a vertex,
properties from an edge, and
properties from a VertexProperty
  • Loading branch information
Cole-Greer committed Aug 14, 2023
1 parent c456e94 commit 782c175
Show file tree
Hide file tree
Showing 12 changed files with 625 additions and 8 deletions.
Original file line number Diff line number Diff line change
Expand Up @@ -281,6 +281,22 @@ public Configuration configuration() {

protected abstract void addInEdge(final TinkerVertex vertex, final String label, final Edge edge);

protected TinkerVertex createTinkerVertex(final Object id, final String label, final AbstractTinkerGraph graph) {
return new TinkerVertex(id, label, graph);
}

protected TinkerVertex createTinkerVertex(final Object id, final String label, final AbstractTinkerGraph graph, final long currentVersion) {
return new TinkerVertex(id, label, graph, currentVersion);
}

protected TinkerEdge createTinkerEdge(final Object id, final Vertex outVertex, final String label, final Vertex inVertex) {
return new TinkerEdge(id, outVertex, label, inVertex);
}

protected TinkerEdge createTinkerEdge(final Object id, final Vertex outVertex, final String label, final Vertex inVertex, final long currentVersion) {
return new TinkerEdge(id, outVertex, label, inVertex, currentVersion);
}

///////////// Features ///////////////

public class TinkerGraphVertexFeatures implements Features.VertexFeatures {
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -38,7 +38,7 @@
/**
* @author Marko A. Rodriguez (http://markorodriguez.com)
*/
public final class TinkerEdge extends TinkerElement implements Edge {
public class TinkerEdge extends TinkerElement implements Edge {

protected Map<String, Property> properties;

Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -59,7 +59,7 @@
@Graph.OptIn(Graph.OptIn.SUITE_PROCESS_COMPUTER)
@Graph.OptIn(Graph.OptIn.SUITE_PROCESS_LIMITED_STANDARD)
@Graph.OptIn(Graph.OptIn.SUITE_PROCESS_LIMITED_COMPUTER)
public final class TinkerGraph extends AbstractTinkerGraph {
public class TinkerGraph extends AbstractTinkerGraph {

static {
TraversalStrategies.GlobalCache.registerStrategies(TinkerGraph.class, TraversalStrategies.GlobalCache.getStrategies(Graph.class).clone().addStrategies(
Expand All @@ -79,7 +79,7 @@ public final class TinkerGraph extends AbstractTinkerGraph {
/**
* An empty private constructor that initializes {@link TinkerGraph}.
*/
private TinkerGraph(final Configuration configuration) {
TinkerGraph(final Configuration configuration) {
this.configuration = configuration;
vertexIdManager = selectIdManager(configuration, GREMLIN_TINKERGRAPH_VERTEX_ID_MANAGER, Vertex.class);
edgeIdManager = selectIdManager(configuration, GREMLIN_TINKERGRAPH_EDGE_ID_MANAGER, Edge.class);
Expand Down Expand Up @@ -146,7 +146,7 @@ public Vertex addVertex(final Object... keyValues) {
idValue = vertexIdManager.getNextId(this);
}

final Vertex vertex = new TinkerVertex(idValue, label, this);
final Vertex vertex = createTinkerVertex(idValue, label, this);
ElementHelper.attachProperties(vertex, VertexProperty.Cardinality.list, keyValues);
this.vertices.put(vertex.id(), vertex);

Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -41,7 +41,7 @@
/**
* @author Marko A. Rodriguez (http://markorodriguez.com)
*/
public final class TinkerVertex extends TinkerElement implements Vertex {
public class TinkerVertex extends TinkerElement implements Vertex {

protected Map<String, List<VertexProperty>> properties;
// Edges should be used by non-transaction Graph due to performance
Expand All @@ -50,7 +50,7 @@ public final class TinkerVertex extends TinkerElement implements Vertex {
// Edge ids are for transactional Graph
protected Map<String, Set<Object>> outEdgesId;
protected Map<String, Set<Object>> inEdgesId;
private final AbstractTinkerGraph graph;
protected final AbstractTinkerGraph graph;
private boolean allowNullPropertyValues;
private final boolean isTxMode;

Expand Down Expand Up @@ -160,7 +160,7 @@ public <V> VertexProperty<V> property(final VertexProperty.Cardinality cardinali
graph.vertexPropertyIdManager.convert(optionalId.get()) :
graph.vertexPropertyIdManager.getNextId(graph);

final VertexProperty<V> vertexProperty = new TinkerVertexProperty<V>(idValue, this, key, value);
final VertexProperty<V> vertexProperty = createTinkerVertexProperty(idValue, this, key, value);

if (null == this.properties) this.properties = new ConcurrentHashMap<>();
final List<VertexProperty> list = this.properties.getOrDefault(key, new ArrayList<>());
Expand Down Expand Up @@ -230,6 +230,14 @@ public Iterator<Vertex> vertices(final Direction direction, final String... edge
: (Iterator) TinkerHelper.getVertices(this, direction, edgeLabels);
}

protected <V> TinkerVertexProperty<V> createTinkerVertexProperty(final TinkerVertex vertex, final String key, final V value, final Object... propertyKeyValues) {
return new TinkerVertexProperty<V>(vertex, key, value, propertyKeyValues);
}

protected <V> TinkerVertexProperty<V> createTinkerVertexProperty(final Object id, final TinkerVertex vertex, final String key, final V value, final Object... propertyKeyValues) {
return new TinkerVertexProperty<V>(id, vertex, key, value, propertyKeyValues);
}

@Override
public <V> Iterator<VertexProperty<V>> properties(final String... propertyKeys) {
if (this.removed) return Collections.emptyIterator();
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,52 @@
/*
* 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.tinkergraph;

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Stage;
import io.cucumber.guice.CucumberModules;
import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;
import org.apache.tinkerpop.gremlin.features.AbstractGuiceFactory;
import org.apache.tinkerpop.gremlin.features.World;
import org.junit.runner.RunWith;

@RunWith(Cucumber.class)
@CucumberOptions(
tags = "not @RemoteOnly and not @GraphComputerOnly and not @AllowNullPropertyValues",
glue = { "org.apache.tinkerpop.gremlin.features" },
objectFactory = TinkerShuffleGraphFeatureTest.TinkerShuffleGraphGuiceFactory.class,
features = { "classpath:/org/apache/tinkerpop/gremlin/test/features" },
plugin = {"progress", "junit:target/cucumber.xml"})
public class TinkerShuffleGraphFeatureTest {

public static class TinkerShuffleGraphGuiceFactory extends AbstractGuiceFactory {
public TinkerShuffleGraphGuiceFactory() {
super(Guice.createInjector(Stage.PRODUCTION, CucumberModules.createScenarioModule(), new ServiceModule()));
}
}

public static final class ServiceModule extends AbstractModule {
@Override
protected void configure() {
bind(World.class).to(TinkerWorld.TinkerShuffleGraphWorld.class);
}
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -36,6 +36,7 @@
import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerFactory;
import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerTransactionGraph;
import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerShuffleGraph;
import org.junit.AssumptionViolatedException;

import java.io.File;
Expand Down Expand Up @@ -149,6 +150,61 @@ public AbstractTinkerGraph open(final Configuration configuration) {

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
* The {@link World} implementation for TinkerShuffleGraph that provides the {@link GraphTraversalSource}
* instances required by the Gherkin test suite.
*/
public static class TinkerShuffleGraphWorld extends TinkerWorld {
private static final TinkerGraph modern;
private static final TinkerGraph classic;
private static final TinkerGraph crew;
private static final TinkerGraph sink;
private static final TinkerGraph grateful;

static {
modern = TinkerShuffleGraph.open();
TinkerFactory.generateModern(modern);
registerTestServices(modern);
classic = TinkerShuffleGraph.open();
TinkerFactory.generateClassic(classic);
registerTestServices(classic);
crew = TinkerShuffleGraph.open();
TinkerFactory.generateTheCrew(crew);
registerTestServices(crew);
sink = TinkerShuffleGraph.open();
TinkerFactory.generateKitchenSink(sink);
registerTestServices(sink);
grateful = TinkerShuffleGraph.open();
TinkerFactory.generateGratefulDead(grateful);
registerTestServices(grateful);
}

@Override
public GraphTraversalSource getGraphTraversalSource(final LoadGraphWith.GraphData graphData) {
if (null == graphData)
return registerTestServices(TinkerGraph.open(getNumberIdManagerConfiguration())).traversal();
else if (graphData == LoadGraphWith.GraphData.CLASSIC)
return classic.traversal();
else if (graphData == LoadGraphWith.GraphData.CREW)
return crew.traversal();
else if (graphData == LoadGraphWith.GraphData.MODERN)
return modern.traversal();
else if (graphData == LoadGraphWith.GraphData.SINK)
return sink.traversal();
else if (graphData == LoadGraphWith.GraphData.GRATEFUL)
return grateful.traversal();
else
throw new UnsupportedOperationException("GraphData not supported: " + graphData.name());
}

@Override
public AbstractTinkerGraph open(final Configuration configuration) {
return TinkerShuffleGraph.open(configuration);
}
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
* Enables the storing of {@code null} property values when testing. This is a terminal decorator and shouldn't be
* used as an input into another decorator.
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,50 @@
/*
* 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.tinkergraph.structure;

import org.apache.tinkerpop.gremlin.structure.Direction;
import org.apache.tinkerpop.gremlin.structure.Property;
import org.apache.tinkerpop.gremlin.structure.Vertex;

import java.util.Iterator;

import static org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerShuffleGraph.shuffleIterator;

/**
* @author Cole Greer (https://github.com/Cole-Greer)
*/
public final class TinkerShuffleEdge extends TinkerEdge {
protected TinkerShuffleEdge(final Object id, final Vertex outVertex, final String label, final Vertex inVertex) {
this(id, outVertex, label, inVertex, 0);
}

protected TinkerShuffleEdge(final Object id, final Vertex outVertex, final String label, final Vertex inVertex, final long currentVersion) {
super(id, outVertex, label, inVertex, currentVersion);
}

@Override
public Iterator<Vertex> vertices(final Direction direction) {
return shuffleIterator(super.vertices(direction));
}

@Override
public <V> Iterator<Property<V>> properties(final String... propertyKeys) {
return shuffleIterator(super.properties(propertyKeys));
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,86 @@
/*
* 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.tinkergraph.structure;

import org.apache.commons.collections.IteratorUtils;
import org.apache.commons.configuration2.BaseConfiguration;
import org.apache.commons.configuration2.Configuration;
import org.apache.tinkerpop.gremlin.structure.Edge;
import org.apache.tinkerpop.gremlin.structure.Graph;
import org.apache.tinkerpop.gremlin.structure.Vertex;

import java.util.Collections;
import java.util.Iterator;
import java.util.List;

/**
* @author Cole Greer (https://github.com/Cole-Greer)
*/
public class TinkerShuffleGraph extends TinkerGraph {

private static final Configuration EMPTY_CONFIGURATION = new BaseConfiguration() {{
this.setProperty(Graph.GRAPH, TinkerShuffleGraph.class.getName());
}};

private TinkerShuffleGraph(Configuration configuration) {
super(configuration);
}

public static TinkerShuffleGraph open() {
return open(EMPTY_CONFIGURATION);
}

public static TinkerShuffleGraph open(Configuration configuration) {
return new TinkerShuffleGraph(configuration);
}

@Override
public Iterator<Vertex> vertices(final Object... vertexIds) {
return shuffleIterator(super.vertices(vertexIds));
}

@Override
public Iterator<Edge> edges(final Object... edgeIds) {
return shuffleIterator(super.edges(edgeIds));
}

@Override
protected TinkerVertex createTinkerVertex(final Object id, final String label, final AbstractTinkerGraph graph) {
return new TinkerShuffleVertex(id, label, graph);
}

protected TinkerVertex createTinkerVertex(final Object id, final String label, final AbstractTinkerGraph graph, final long currentVersion) {
return new TinkerShuffleVertex(id, label, graph, currentVersion);
}

protected TinkerEdge createTinkerEdge(final Object id, final Vertex outVertex, final String label, final Vertex inVertex) {
return new TinkerShuffleEdge(id, outVertex, label, inVertex);
}

protected TinkerEdge createTinkerEdge(final Object id, final Vertex outVertex, final String label, final Vertex inVertex, final long currentVersion) {
return new TinkerShuffleEdge(id, outVertex, label, inVertex, currentVersion);
}

static Iterator shuffleIterator(Iterator iter) {
List list = IteratorUtils.toList(iter);
Collections.shuffle(list);
return list.iterator();
}

}
Loading

0 comments on commit 782c175

Please sign in to comment.