Coverage Summary for Class: TestGremlinCompileWithAs (org.umlg.sqlg.test.gremlincompile)

Class Class, % Method, % Branch, % Line, %
TestGremlinCompileWithAs 100% (1/1) 100% (12/12) 50% (9/18) 100% (151/151)


 package org.umlg.sqlg.test.gremlincompile;
 
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.DefaultGraphTraversal;
 import org.apache.tinkerpop.gremlin.structure.Edge;
 import org.apache.tinkerpop.gremlin.structure.Element;
 import org.apache.tinkerpop.gremlin.structure.T;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
 import org.junit.Assert;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.umlg.sqlg.structure.SqlgGraph;
 import org.umlg.sqlg.test.BaseTest;
 
 import java.util.*;
 
 /**
  * Date: 2015/01/19
  * Time: 6:22 AM
  */
 public class TestGremlinCompileWithAs extends BaseTest {
 
  @BeforeClass
  public static void beforeClass() {
  BaseTest.beforeClass();
  if (isPostgres()) {
  configuration.addProperty("distributed", true);
  }
  }
 
  @Test
  public void testSchemaTableTreeNextSchemaTableTreeIsEdgeVertex() throws InterruptedException {
  Vertex a1 = this.sqlgGraph.addVertex(T.label, "A", "name", "a1");
  Vertex b1 = this.sqlgGraph.addVertex(T.label, "B", "name", "b1");
  Vertex c1 = this.sqlgGraph.addVertex(T.label, "C", "name", "c1");
  a1.addEdge("outA", b1);
  b1.addEdge("outB", c1);
  this.sqlgGraph.tx().commit();
  testSchemaTableTreeNextSchemaTableTreeIsEdgeVertex_assert(this.sqlgGraph, a1, b1, c1);
  if (this.sqlgGraph1 != null) {
  Thread.sleep(SLEEP_TIME);
  testSchemaTableTreeNextSchemaTableTreeIsEdgeVertex_assert(this.sqlgGraph1, a1, b1, c1);
  }
 
  }
 
  @SuppressWarnings("unchecked")
  private void testSchemaTableTreeNextSchemaTableTreeIsEdgeVertex_assert(SqlgGraph sqlgGraph, Vertex a1, Vertex b1, Vertex c1) {
  DefaultGraphTraversal<Vertex, Map<String, Vertex>> gt = (DefaultGraphTraversal)sqlgGraph.traversal().V(a1).out().as("b").out().as("c").select("b", "c");
  Assert.assertEquals(4, gt.getSteps().size());
  List<Map<String, Vertex>> list = gt.toList();
  Assert.assertEquals(2, gt.getSteps().size());
  Assert.assertEquals(1, list.size());
  Assert.assertEquals(b1, list.get(0).get("b"));
  Assert.assertEquals(c1, list.get(0).get("c"));
  }
 
  @Test
  public void testHasLabelOutWithAs() throws InterruptedException {
  Vertex a1 = this.sqlgGraph.addVertex(T.label, "A", "name", "a1");
  Vertex b1 = this.sqlgGraph.addVertex(T.label, "B", "name", "b1");
  Vertex b2 = this.sqlgGraph.addVertex(T.label, "B", "name", "b2");
  Vertex b3 = this.sqlgGraph.addVertex(T.label, "B", "name", "b3");
  Vertex b4 = this.sqlgGraph.addVertex(T.label, "B", "name", "b4");
  Edge e1 = a1.addEdge("outB", b1, "edgeName", "edge1");
  Edge e2 = a1.addEdge("outB", b2, "edgeName", "edge2");
  Edge e3 = a1.addEdge("outB", b3, "edgeName", "edge3");
  Edge e4 = a1.addEdge("outB", b4, "edgeName", "edge4");
  this.sqlgGraph.tx().commit();
  testHasLabelOutWithAs_assert(this.sqlgGraph, a1, b1, b2, b3, b4, e1, e2, e3, e4);
  if (this.sqlgGraph1 != null) {
  Thread.sleep(SLEEP_TIME);
  testHasLabelOutWithAs_assert(this.sqlgGraph1, a1, b1, b2, b3, b4, e1, e2, e3, e4);
  }
 
  }
 
  private void testHasLabelOutWithAs_assert(SqlgGraph sqlgGraph, Vertex a1, Vertex b1, Vertex b2, Vertex b3, Vertex b4, Edge e1, Edge e2, Edge e3, Edge e4) {
  DefaultGraphTraversal<Vertex, Map<String, Element>> traversal = (DefaultGraphTraversal<Vertex, Map<String, Element>>)sqlgGraph.traversal().V(a1)
  .outE("outB")
  .as("e")
  .inV()
  .as("B")
  .<Element>select("e", "B");
  Assert.assertEquals(4, traversal.getSteps().size());
  List<Map<String, Element>> result = traversal.toList();
  Assert.assertEquals(2, traversal.getSteps().size());
  result.sort(Comparator.comparing(o -> o.get("e").<String>value("edgeName")));
  Assert.assertEquals(4, result.size());
 
  Edge queryE0 = (Edge) result.get(0).get("e");
  Vertex queryB0 = (Vertex) result.get(0).get("B");
  Assert.assertEquals(e1, queryE0);
  Assert.assertEquals("b1", queryE0.inVertex().value("name"));
  Assert.assertEquals("a1", queryE0.outVertex().value("name"));
  Assert.assertEquals("edge1", queryE0.value("edgeName"));
  Assert.assertEquals(b1, queryB0);
  Assert.assertEquals("b1", queryB0.value("name"));
 
  Element queryE2 = result.get(1).get("e");
  Element queryB2 = result.get(1).get("B");
  Assert.assertEquals(e2, queryE2);
  Assert.assertEquals("edge2", queryE2.value("edgeName"));
  Assert.assertEquals(b2, queryB2);
  Assert.assertEquals("b2", queryB2.value("name"));
 
  Element queryE3 = result.get(2).get("e");
  Element queryB3 = result.get(2).get("B");
  Assert.assertEquals(e3, queryE3);
  Assert.assertEquals("edge3", queryE3.value("edgeName"));
  Assert.assertEquals(b3, queryB3);
  Assert.assertEquals("b3", queryB3.value("name"));
 
  Element queryE4 = result.get(3).get("e");
  Element queryB4 = result.get(3).get("B");
  Assert.assertEquals(e4, queryE4);
  Assert.assertEquals("edge4", queryE4.value("edgeName"));
  Assert.assertEquals(b4, queryB4);
  Assert.assertEquals("b4", queryB4.value("name"));
 
  DefaultGraphTraversal<Vertex, Edge> traversal1 = (DefaultGraphTraversal<Vertex, Edge>) sqlgGraph.traversal().V(a1.id()).bothE();
  Assert.assertEquals(2, traversal1.getSteps().size());
  final List<Edge> a1Edges = traversal1.toList();
  Assert.assertEquals(1, traversal1.getSteps().size());
  Assert.assertEquals(4, a1Edges.size());
  List<String> names = new ArrayList<>(Arrays.asList("b1", "b2", "b3", "b4"));
  for (Edge a1Edge : a1Edges) {
  names.remove(a1Edge.inVertex().<String>value("name"));
  Assert.assertEquals("a1", a1Edge.outVertex().<String>value("name"));
  }
  Assert.assertTrue(names.isEmpty());
  }
 
  @Test
  public void testHasLabelOutWithAsNotFromStart() throws InterruptedException {
  Vertex a1 = this.sqlgGraph.addVertex(T.label, "A", "name", "a1");
  Vertex b1 = this.sqlgGraph.addVertex(T.label, "B", "name", "b1");
  Vertex b2 = this.sqlgGraph.addVertex(T.label, "B", "name", "b2");
  Vertex b3 = this.sqlgGraph.addVertex(T.label, "B", "name", "b3");
  Vertex b4 = this.sqlgGraph.addVertex(T.label, "B", "name", "b4");
  Vertex c1 = this.sqlgGraph.addVertex(T.label, "C", "name", "c1");
  Vertex c2 = this.sqlgGraph.addVertex(T.label, "C", "name", "c2");
  a1.addEdge("outB", b1, "edgeName", "edge1");
  a1.addEdge("outB", b2, "edgeName", "edge2");
  a1.addEdge("outB", b3, "edgeName", "edge3");
  a1.addEdge("outB", b4, "edgeName", "edge4");
  b1.addEdge("outC", c1, "edgeName", "edge5");
  b2.addEdge("outC", c2, "edgeName", "edge6");
 
  this.sqlgGraph.tx().commit();
  testHasLabelOutWithAsNotFromStart_assert(this.sqlgGraph, a1, c1, c2);
  if (this.sqlgGraph1 != null) {
  Thread.sleep(SLEEP_TIME);
  testHasLabelOutWithAsNotFromStart_assert(this.sqlgGraph1, a1, c1, c2);
  }
 
  }
 
  private void testHasLabelOutWithAsNotFromStart_assert(SqlgGraph sqlgGraph, Vertex a1, Vertex c1, Vertex c2) {
  DefaultGraphTraversal<Vertex, Vertex> traversal = (DefaultGraphTraversal<Vertex, Vertex>) sqlgGraph.traversal().V(a1)
  .out("outB")
  .out("outC")
  .as("x")
  .<Vertex>select("x");
  Assert.assertEquals(4, traversal.getSteps().size());
  List<Vertex> result = traversal.toList();
  Assert.assertEquals(2, traversal.getSteps().size());
  result.sort(Comparator.comparing(o -> o.<String>value("name")));
  Assert.assertEquals(2, result.size());
 
  Assert.assertEquals(c1, result.get(0));
  Assert.assertEquals(c2, result.get(1));
  }
 
  @Test
  public void testAsWithDuplicatePaths() throws InterruptedException {
  Vertex a1 = this.sqlgGraph.addVertex(T.label, "Person", "name", "a1");
  Vertex a2 = this.sqlgGraph.addVertex(T.label, "Person", "name", "a2");
  Edge e1 = a1.addEdge("friend", a2, "weight", 5);
  this.sqlgGraph.tx().commit();
 
  testAsWithDuplicatePaths_assert(this.sqlgGraph, a1, e1);
  if (this.sqlgGraph1 != null) {
  Thread.sleep(SLEEP_TIME);
  testAsWithDuplicatePaths_assert(this.sqlgGraph1, a1, e1);
  }
  }
 
  private void testAsWithDuplicatePaths_assert(SqlgGraph sqlgGraph, Vertex a1, Edge e1) {
  DefaultGraphTraversal<Vertex, Map<String, Element>> gt = (DefaultGraphTraversal<Vertex, Map<String, Element>>) sqlgGraph.traversal()
  .V(a1)
  .outE().as("e")
  .inV()
  .in().as("v")
  .<Element>select("e", "v");
  Assert.assertEquals(5, gt.getSteps().size());
 
  List<Map<String, Element>> result = gt.toList();
  Assert.assertEquals(2, gt.getSteps().size());
  Assert.assertEquals(1, result.size());
  Assert.assertEquals(e1, result.get(0).get("e"));
  Assert.assertEquals(a1, result.get(0).get("v"));
  }
 
  @Test
  public void testChainSelect() throws Exception {
  Vertex a1 = this.sqlgGraph.addVertex(T.label, "Person", "name", "a1");
  Vertex a2 = this.sqlgGraph.addVertex(T.label, "Person", "name", "a2");
  a1.addEdge("friend", a2, "weight", 5);
  this.sqlgGraph.tx().commit();
 
  testChainSelect_assert(this.sqlgGraph, a2);
  if (this.sqlgGraph1 != null) {
  Thread.sleep(SLEEP_TIME);
  testChainSelect_assert(this.sqlgGraph1, a2);
  }
 
  }
 
  private void testChainSelect_assert(SqlgGraph sqlgGraph, Vertex a2) throws Exception {
  try (DefaultGraphTraversal<Vertex, Vertex> gt = (DefaultGraphTraversal<Vertex, Vertex>) sqlgGraph.traversal()
  .V().hasLabel("Person").has("name", "a1").as("v1")
  .values("name").as("name1")
  .select("v1")
  .out("friend")) {
  Assert.assertEquals(5, gt.getSteps().size());
  Assert.assertTrue(gt.hasNext());
  Assert.assertEquals(5, gt.getSteps().size());
  Assert.assertEquals(a2, gt.next());
  Assert.assertFalse(gt.hasNext());
  }
  }
 }