Exemplo n.º 1
0
 private static void createVertexProperty(
     final Graph graphToWriteTo,
     final Vertex v,
     final VertexProperty<Object> p,
     final boolean hidden) {
   final List<Object> propertyArgs = new ArrayList<>();
   if (graphToWriteTo.features().vertex().properties().supportsUserSuppliedIds())
     appendToArgList(propertyArgs, T.id, p.id());
   p.iterators()
       .propertyIterator()
       .forEachRemaining(it -> appendToArgList(propertyArgs, it.key(), it.value()));
   // p.iterators().hiddenPropertyIterator().forEachRemaining(it -> appendToArgList(propertyArgs,
   // Graph.Key.hide(it.key()), it.value()));
   v.property(hidden ? Graph.Key.hide(p.key()) : p.key(), p.value(), propertyArgs.toArray());
 }
/** @author Stephen Mallette (http://stephen.genoprime.com) */
public class PartitionGraphStrategyTest extends AbstractGremlinTest {
  private static final String partition = Graph.Key.hidden("partition");

  public PartitionGraphStrategyTest() {
    super(new PartitionGraphStrategy(partition, "A"));
  }

  @Test
  public void shouldAppendPartitionToVertex() {
    final Vertex v = g.addVertex("any", "thing");

    assertNotNull(v);
    assertEquals("thing", v.property("any").value());
    assertEquals("A", v.property(partition).value());
  }

  @Test
  public void shouldAppendPartitionToEdge() {
    final Vertex v1 = g.addVertex("any", "thing");
    final Vertex v2 = g.addVertex("some", "thing");
    final Edge e = v1.addEdge("connectsTo", v2, "every", "thing");

    assertNotNull(v1);
    assertEquals("thing", v1.property("any").value());
    assertEquals("A", v2.property(partition).value());

    assertNotNull(v2);
    assertEquals("thing", v2.property("some").value());
    assertEquals("A", v2.property(partition).value());

    assertNotNull(e);
    assertEquals("thing", e.property("every").value());
    assertEquals("connectsTo", e.label());
    assertEquals("A", e.property(partition).value());
  }

  @Test
  public void shouldWriteVerticesToMultiplePartitions() {
    final Vertex vA = g.addVertex("any", "a");
    final PartitionGraphStrategy strategy =
        (PartitionGraphStrategy) ((StrategyWrappedGraph) g).strategy().getGraphStrategy().get();
    strategy.setWritePartition("B");
    final Vertex vB = g.addVertex("any", "b");

    assertNotNull(vA);
    assertEquals("a", vA.property("any").value());
    assertEquals("A", vA.property(partition).value());

    assertNotNull(vB);
    assertEquals("b", vB.property("any").value());
    assertEquals("B", vB.property(partition).value());

    /* not applicable to SubgraphStrategy
    final GraphTraversal t = g.V();
    assertTrue(t.strategies().get().stream().anyMatch(o -> o.getClass().equals(PartitionGraphStrategy.PartitionGraphTraversalStrategy.class)));
    */

    g.V()
        .forEach(
            v -> {
              assertTrue(v instanceof StrategyWrappedVertex);
              assertEquals("a", v.property("any").value());
            });

    strategy.removeReadPartition("A");
    strategy.addReadPartition("B");

    g.V()
        .forEach(
            v -> {
              assertTrue(v instanceof StrategyWrappedVertex);
              assertEquals("b", v.property("any").value());
            });

    strategy.addReadPartition("A");
    assertEquals(new Long(2), g.V().count().next());
  }

  @Test
  public void shouldThrowExceptionOnvInDifferentPartition() {
    final Vertex vA = g.addVertex("any", "a");
    assertEquals(vA.id(), g.v(vA.id()).id());

    final PartitionGraphStrategy strategy =
        (PartitionGraphStrategy) ((StrategyWrappedGraph) g).strategy().getGraphStrategy().get();
    strategy.clearReadPartitions();

    try {
      g.v(vA.id());
    } catch (Exception ex) {
      final Exception expected = Graph.Exceptions.elementNotFound(Vertex.class, vA.id());
      assertEquals(expected.getClass(), ex.getClass());
      assertEquals(expected.getMessage(), ex.getMessage());
    }
  }

  @Test
  public void shouldThrowExceptionOneInDifferentPartition() {
    final Vertex vA = g.addVertex("any", "a");
    final Edge e = vA.addEdge("knows", vA);
    assertEquals(e.id(), g.e(e.id()).id());

    final PartitionGraphStrategy strategy =
        (PartitionGraphStrategy) ((StrategyWrappedGraph) g).strategy().getGraphStrategy().get();
    strategy.clearReadPartitions();

    try {
      g.e(e.id());
    } catch (Exception ex) {
      final Exception expected = Graph.Exceptions.elementNotFound(Edge.class, e.id());
      assertEquals(expected.getClass(), ex.getClass());
      assertEquals(expected.getMessage(), ex.getMessage());
    }
  }

  @Test
  public void shouldWriteToMultiplePartitions() {
    final Vertex vA = g.addVertex("any", "a");
    final Vertex vAA = g.addVertex("any", "aa");
    final Edge eAtoAA = vA.addEdge("a->a", vAA);

    final PartitionGraphStrategy strategy =
        (PartitionGraphStrategy) ((StrategyWrappedGraph) g).strategy().getGraphStrategy().get();
    strategy.setWritePartition("B");
    final Vertex vB = g.addVertex("any", "b");
    vA.addEdge("a->b", vB);

    strategy.setWritePartition("C");
    final Vertex vC = g.addVertex("any", "c");
    final Edge eBtovC = vB.addEdge("b->c", vC);
    final Edge eAtovC = vA.addEdge("a->c", vC);

    /* not applicable to SubgraphStrategy
    final GraphTraversal t = g.V();
    assertTrue(t.strategies().get().stream().anyMatch(o -> o.getClass().equals(PartitionGraphStrategy.PartitionGraphTraversalStrategy.class)));
    */

    strategy.clearReadPartitions();
    assertEquals(new Long(0), g.V().count().next());
    assertEquals(new Long(0), g.E().count().next());

    strategy.addReadPartition("A");
    assertEquals(new Long(2), g.V().count().next());
    assertEquals(new Long(1), g.E().count().next());
    assertEquals(new Long(1), g.v(vA.id()).outE().count().next());
    assertEquals(eAtoAA.id(), g.v(vA.id()).outE().next().id());
    assertEquals(new Long(1), g.v(vA.id()).out().count().next());
    assertEquals(vAA.id(), g.v(vA.id()).out().next().id());

    strategy.addReadPartition("B");
    assertEquals(new Long(3), g.V().count().next());
    assertEquals(new Long(2), g.E().count().next());

    strategy.addReadPartition("C");
    assertEquals(new Long(4), g.V().count().next());
    assertEquals(new Long(4), g.E().count().next());

    strategy.removeReadPartition("A");
    strategy.removeReadPartition("B");

    assertEquals(new Long(1), g.V().count().next());
    // two edges are in the "C" partition, but one each of their incident vertices are not
    assertEquals(new Long(0), g.E().count().next());

    assertEquals(new Long(0), g.v(vC.id()).inE().count().next());
    assertEquals(new Long(0), g.v(vC.id()).in().count().next());

    strategy.addReadPartition("B");
    // only one edge in, due to excluded vertices; vA is not in {B,C}
    assertEquals(new Long(1), g.v(vC.id()).inE().count().next());
    assertEquals(new Long(1), g.v(vC.id()).in().count().next());
    assertEquals(vC.id(), g.e(eBtovC.id()).inV().id().next());
    assertEquals(vB.id(), g.e(eBtovC.id()).outV().id().next());
    assertEquals(vC.id(), g.e(eAtovC.id()).inV().id().next());
    assertFalse(g.e(eAtovC.id()).outV().hasNext());

    /* not applicable to SubgraphStrategy
    strategy.addReadPartition("A");
    g.v(vA.id()).out().out().forEach(v -> {
        assertTrue(v instanceof StrategyWrapped);
        assertFalse(((StrategyWrappedElement) v).getBaseElement() instanceof StrategyWrapped);
    });

    g.v(vA.id()).outE().inV().outE().forEach(e -> {
        assertTrue(e instanceof StrategyWrapped);
        assertFalse(((StrategyWrappedElement) e).getBaseElement() instanceof StrategyWrapped);
    });
    */
  }

  @Test
  public void shouldWrapProperties() {
    final Vertex v = g.addVertex("any", "a");
    final Edge e = v.addEdge("to", v, "all", "a");

    assertTrue(v.property("any") instanceof StrategyWrappedProperty);
    assertTrue(v.properties().get("any") instanceof StrategyWrappedProperty);

    assertTrue(e.property("all") instanceof StrategyWrappedProperty);
    assertTrue(e.properties().get("all") instanceof StrategyWrappedProperty);

    assertTrue(g.V().property("any").next() instanceof StrategyWrappedProperty);
    assertTrue(g.E().property("any").next() instanceof StrategyWrappedProperty);
  }
}