private static void assertNumStep(int expectedResults, int expectedSteps, GraphTraversal traversal, Class<? extends Step>... expectedStepTypes) { int num = 0; while (traversal.hasNext()) { traversal.next(); num++; } // System.out.println(traversal); assertEquals(expectedResults, num); //Verify that steps line up with what is expected after Titan's optimizations are applied List<Step> steps = traversal.asAdmin().getSteps(); Set<Class<? extends Step>> expSteps = Sets.newHashSet(expectedStepTypes); int numSteps = 0; for (Step s : steps) { // System.out.println(s.getClass()); if (s.getClass().equals(GraphStep.class) || s.getClass().equals(StartStep.class)) continue; assertTrue(s.getClass().getName(), expSteps.contains(s.getClass())); numSteps++; } assertEquals(expectedSteps, numSteps); }
private static void assertNumStep(int expectedResults, int expectedSteps, GraphTraversal traversal, Class<? extends Step>... expectedStepTypes) { int num = 0; while (traversal.hasNext()) { traversal.next(); num++; } assertEquals(expectedResults, num); //Verify that steps line up with what is expected after JanusGraph's optimizations are applied List<Step> steps = traversal.asAdmin().getSteps(); Set<Class<? extends Step>> expSteps = Sets.newHashSet(expectedStepTypes); int numSteps = 0; for (Step s : steps) { if (s.getClass().equals(GraphStep.class) || s.getClass().equals(StartStep.class)) continue; if (expSteps.contains(s.getClass())) { numSteps++; } } assertEquals(expectedSteps, numSteps); }
public static<E extends Element> void assertTraversal(GraphTraversal<?, E> req, E... expectedElements) { for (final E expectedElement : expectedElements) { assertEquals(expectedElement, req.next()); } assertFalse(req.hasNext()); }
private void removeVertex(String property, Object value) { final GraphTraversal<Vertex, Vertex> traversal = graph.traversal().V().has(property, value); if (traversal.hasNext()) { traversal.next().remove(); graph.tx().commit(); } }
private void updateVertexWithProperties(String propertyKey, Object propertyValue, Map<Object, Object> map) { if (graph.traversal().V().has(propertyKey, propertyValue).hasNext()) { final Vertex v = graph.traversal().V().has(propertyKey, propertyValue).next(); map.forEach((key, value) -> v.property((String) key, value)); graph.tx().commit(); } }
@Test public void testOrForceIndexComposite() throws Exception { JanusGraph customGraph = null; try { customGraph = this.getForceIndexGraph(); final JanusGraphManagement management = customGraph.openManagement(); management.makePropertyKey("name").dataType(String.class).cardinality(Cardinality.SINGLE).make(); final PropertyKey ageProperty = management.makePropertyKey("age").dataType(Integer.class).cardinality(Cardinality.SINGLE).make(); management.buildIndex("ageridx", Vertex.class).addKey(ageProperty).buildCompositeIndex(); management.commit(); customGraph.tx().commit(); final GraphTraversalSource g = customGraph.traversal(); g.addV().property("name", "Hiro").property("age", 2).next(); g.addV().property("name", "Totoro").property("age", 1).next(); customGraph.tx().commit(); g.V().has("age", P.gte(4).or(P.lt(2))).hasNext(); fail("should fail"); } catch (final JanusGraphException e){ assertTrue(e.getMessage().contains("Could not find a suitable index to answer graph query and graph scans are disabled")); } finally { if (customGraph != null) { JanusGraphFactory.close(customGraph); } } } }
@Test public void testOrForceIndexPartialIndex() throws Exception { JanusGraph customGraph = null; try { customGraph = this.getForceIndexGraph(); final JanusGraphManagement management = customGraph.openManagement(); final PropertyKey stringProperty = management.makePropertyKey("name").dataType(String.class).cardinality(Cardinality.SINGLE).make(); management.makePropertyKey("age").dataType(Integer.class).cardinality(Cardinality.SINGLE).make(); management.buildIndex("oridx", Vertex.class).addKey(stringProperty, getStringMapping()).buildMixedIndex(INDEX); management.commit(); customGraph.tx().commit(); final GraphTraversalSource g = customGraph.traversal(); g.addV().property("name", "Hiro").property("age", 2).next(); g.addV().property("name", "Totoro").property("age", 1).next(); customGraph.tx().commit(); g.V().or(__.has("name", "Totoro"),__.has("age", 2)).hasNext(); fail("should fail"); } catch (final JanusGraphException e){ assertTrue(e.getMessage().contains("Could not find a suitable index to answer graph query and graph scans are disabled")); } finally { if (customGraph != null) { JanusGraphFactory.close(customGraph); } } }
@Test @Ignore @LoadGraphWith(MODERN) public void shouldNotAlterTraversalAfterTraversalBecomesLocked() { final GraphTraversal<Vertex, Vertex> traversal = this.g.V(); assertTrue(traversal.hasNext()); try { traversal.count().next(); fail("Should throw: " + Traversal.Exceptions.traversalIsLocked()); } catch (IllegalStateException e) { assertEquals(Traversal.Exceptions.traversalIsLocked().getMessage(), e.getMessage()); } catch (Exception e) { fail("Should throw: " + Traversal.Exceptions.traversalIsLocked() + " not " + e + ":" + e.getMessage()); } traversal.iterate(); assertFalse(traversal.hasNext()); }
assertThat(gOverAB.V(v).properties("any").hasNext(), is(true)); assertThat(gOverAB.V(v).properties("that").hasNext(), is(true)); assertThat(gOverA.V(v).properties("that").hasNext(), is(false)); assertThat(gOverA.V(v).properties("any").hasNext(), is(true)); assertThat(gOverB.V(v).properties("any").hasNext(), is(false)); assertThat(gOverB.V(v).properties("that").hasNext(), is(false)); assertThat(gOverAB.V(v).properties("partitionKey").hasNext(), is(false)); assertThat(gOverAB.V(v).values("any").hasNext(), is(true)); assertThat(gOverAB.V(v).values("that").hasNext(), is(true)); assertThat(gOverA.V(v).values("that").hasNext(), is(false)); assertThat(gOverA.V(v).values("any").hasNext(), is(true)); assertThat(gOverB.V(v).values("any").hasNext(), is(false)); assertThat(gOverB.V(v).values("that").hasNext(), is(false)); assertThat(gOverAB.V(v).values("partitionKey").hasNext(), is(false)); assertThat(gOverA.V(v).propertyMap().next().containsKey("that"), is(false)); assertThat(gOverA.V(v).propertyMap().next().containsKey("any"), is(true)); assertThat(gOverB.V(v).propertyMap().hasNext(), is(false)); assertThat(gOverB.V(v).propertyMap().hasNext(), is(false)); assertThat(gOverAB.V(v).propertyMap().next().containsKey(partition), is(false)); assertThat(gOverA.V(v).valueMap().next().containsKey("that"), is(false)); assertThat(gOverA.V(v).valueMap().next().containsKey("any"), is(true)); assertThat(gOverB.V(v).valueMap().hasNext(), is(false)); assertThat(gOverB.V(v).valueMap().hasNext(), is(false)); assertThat(gOverAB.V(v).valueMap().next().containsKey(partition), is(false));
james.addEdge("look", book6, "timestamp", "2017-5-3 12:00:08.0"); graph.tx().commit(); assert graph.traversal().V(book6.id()).bothE().hasNext(); System.out.println(">>>> removing vertex: " + james); james.remove(); graph.tx().commit(); assert !graph.traversal().V(james.id()).hasNext(); assert !graph.traversal().V(book6.id()).bothE().hasNext(); edge.remove(); graph.tx().commit(); assert !graph.traversal().E(edgeId).hasNext();
@Test @LoadGraphWith public void shouldNeverPropagateANullValuedTraverser() { try { assertFalse(g.V().map(t -> null).hasNext()); assertEquals(0, g.V().map(t -> null).toList().size()); g.V().map(t -> null).sideEffect(t -> fail("this should not have happened")).iterate(); } catch (VerificationException e) { // its okay if lambdas can't be serialized by the test suite } }
GraphTraversal t = tg.V(clonedVertex).outE(originalEdge.label()); originalEdge.properties().forEachRemaining(p -> t.has(p.key(), p.value())); assertTrue(t.hasNext()); }); });
@Test @LoadGraphWith(MODERN) public void shouldProcessResultGraphOriginalWithPersistNothing() throws Exception { final GraphComputer computer = graphProvider.getGraphComputer(graph); if (computer.features().supportsResultGraphPersistCombination(GraphComputer.ResultGraph.ORIGINAL, GraphComputer.Persist.NOTHING)) { final ComputerResult result = computer.program(new VertexProgramK()).result(GraphComputer.ResultGraph.ORIGINAL).persist(GraphComputer.Persist.NOTHING).submit().get(); assertEquals(Long.valueOf(6l), result.graph().traversal().V().count().next()); assertEquals(Long.valueOf(6l), result.graph().traversal().E().count().next()); assertEquals(Long.valueOf(12l), result.graph().traversal().V().values().count().next()); assertEquals(Long.valueOf(6l), result.graph().traversal().E().values().count().next()); assertFalse(result.graph().traversal().V().values("money").sum().hasNext()); /// assertEquals(Long.valueOf(6l), graph.traversal().V().count().next()); assertEquals(Long.valueOf(6l), graph.traversal().E().count().next()); assertEquals(Long.valueOf(12l), graph.traversal().V().values().count().next()); assertEquals(Long.valueOf(6l), graph.traversal().E().values().count().next()); assertFalse(graph.traversal().V().values("money").sum().hasNext()); } }
@Test @LoadGraphWith(MODERN) public void shouldProcessResultGraphNewWithPersistNothing() throws Exception { final GraphComputer computer = graphProvider.getGraphComputer(graph); if (computer.features().supportsResultGraphPersistCombination(GraphComputer.ResultGraph.NEW, GraphComputer.Persist.NOTHING)) { final ComputerResult result = computer.program(new VertexProgramK()).result(GraphComputer.ResultGraph.NEW).persist(GraphComputer.Persist.NOTHING).submit().get(); assertEquals(Long.valueOf(0l), result.graph().traversal().V().count().next()); assertEquals(Long.valueOf(0l), result.graph().traversal().E().count().next()); assertEquals(Long.valueOf(0l), result.graph().traversal().V().values().count().next()); assertEquals(Long.valueOf(0l), result.graph().traversal().E().values().count().next()); assertFalse(result.graph().traversal().V().values("money").sum().hasNext()); /// assertEquals(Long.valueOf(6l), graph.traversal().V().count().next()); assertEquals(Long.valueOf(6l), graph.traversal().E().count().next()); assertEquals(Long.valueOf(12l), graph.traversal().V().values().count().next()); assertEquals(Long.valueOf(6l), graph.traversal().E().values().count().next()); assertFalse(graph.traversal().V().values("money").sum().hasNext()); } }
@Test @LoadGraphWith public void shouldNeverPropagateANoBulkTraverser() { try { assertFalse(g.V().dedup().sideEffect(t -> t.asAdmin().setBulk(0)).hasNext()); assertEquals(0, g.V().dedup().sideEffect(t -> t.asAdmin().setBulk(0)).toList().size()); g.V().dedup().sideEffect(t -> t.asAdmin().setBulk(0)).sideEffect(t -> fail("this should not have happened")).iterate(); } catch (VerificationException e) { // its okay if lambdas can't be serialized by the test suite } }
@Test @LoadGraphWith(MODERN) public void shouldProcessResultGraphNewWithPersistVertexProperties() throws Exception { final GraphComputer computer = graphProvider.getGraphComputer(graph); if (computer.features().supportsResultGraphPersistCombination(GraphComputer.ResultGraph.NEW, GraphComputer.Persist.VERTEX_PROPERTIES)) { final ComputerResult result = computer.program(new VertexProgramK()).result(GraphComputer.ResultGraph.NEW).persist(GraphComputer.Persist.VERTEX_PROPERTIES).submit().get(); assertEquals(Long.valueOf(6l), result.graph().traversal().V().count().next()); assertEquals(Long.valueOf(0l), result.graph().traversal().E().count().next()); assertEquals(Long.valueOf(18l), result.graph().traversal().V().values().count().next()); assertEquals(Long.valueOf(0l), result.graph().traversal().E().values().count().next()); assertEquals(28l, result.graph().traversal().V().values("money").sum().next()); /// assertEquals(Long.valueOf(6l), graph.traversal().V().count().next()); assertEquals(Long.valueOf(6l), graph.traversal().E().count().next()); assertEquals(Long.valueOf(12l), graph.traversal().V().values().count().next()); assertEquals(Long.valueOf(6l), graph.traversal().E().values().count().next()); assertFalse(graph.traversal().V().values("money").sum().hasNext()); } }
@Test @LoadGraphWith(MODERN) public void shouldProcessResultGraphNewWithPersistEdges() throws Exception { final GraphComputer computer = graphProvider.getGraphComputer(graph); if (computer.features().supportsResultGraphPersistCombination(GraphComputer.ResultGraph.NEW, GraphComputer.Persist.EDGES)) { final ComputerResult result = computer.program(new VertexProgramK()).result(GraphComputer.ResultGraph.NEW).persist(GraphComputer.Persist.EDGES).submit().get(); assertEquals(Long.valueOf(6l), result.graph().traversal().V().count().next()); assertEquals(Long.valueOf(6l), result.graph().traversal().E().count().next()); assertEquals(Long.valueOf(18l), result.graph().traversal().V().values().count().next()); assertEquals(Long.valueOf(6l), result.graph().traversal().E().values().count().next()); assertEquals(28l, result.graph().traversal().V().values("money").sum().next()); /// assertEquals(Long.valueOf(6l), graph.traversal().V().count().next()); assertEquals(Long.valueOf(6l), graph.traversal().E().count().next()); assertEquals(Long.valueOf(12l), graph.traversal().V().values().count().next()); assertEquals(Long.valueOf(6l), graph.traversal().E().values().count().next()); assertFalse(graph.traversal().V().values("money").sum().hasNext()); } }
@Test @FeatureRequirementSet(FeatureRequirementSet.Package.VERTICES_ONLY) @FeatureRequirement(featureClass = Graph.Features.VertexFeatures.class, feature = Graph.Features.VertexFeatures.FEATURE_META_PROPERTIES) public void shouldNotAppendPartitionToVertexProperty() { final PartitionStrategy partitionStrategy = PartitionStrategy.build() .includeMetaProperties(false) .partitionKey(partition).writePartition("A").readPartitions("A").create(); final Vertex v = g.withStrategies(partitionStrategy).addV().property("any", "thing").next(); assertNotNull(v); assertEquals("thing", g.V(v).values("any").next()); assertEquals("A", g.V(v).values(partition).next()); assertThat(g.V(v).properties("any").properties().hasNext(), is(false)); }
assertThat(gts.V().has("any").hasNext(), is(false));