public async Task <dynamic> topUsersTopProducts()
{
var g = AnonymousTraversalSource.Traversal();
GremlinQuery q = g.V()
.HasLabel("person")
.Group <dynamic, dynamic>()
.By(__.Values <dynamic>("firstName"))
.By(__.OutE().HasLabel("published")
.Group <dynamic, dynamic>()
.By(__.InV().HasLabel("product"))
.By(__.InV().HasLabel("product").OutE().HasLabel("is bookmarked by").Count())
.Order(Scope.Local).By(Column.Values, Order.Decr).Limit <dynamic>(Scope.Local, 5)
.Unfold <dynamic>()
.Project <dynamic>("title", new string[] { "bookmarks" })
.By(__.Select <dynamic>(Column.Keys).Unfold <dynamic>().Values <string>("title"))
.By(__.Select <dynamic>(Column.Values).Unfold <dynamic>()).Fold()
)
.ToGremlinQuery();
var queryRes = await gremlinService.ExecuteGremlinQuery <dynamic>(q);
var qq = JsonConvert.SerializeObject(queryRes);
var deserialized = JsonConvert.DeserializeObject <dynamic>(qq);
return(deserialized);
}
public async Task ShouldSupportRemoteTransactionsCommit()
{
var g = AnonymousTraversalSource.Traversal().WithRemote(_connection);
var tx = g.Tx();
var gtx = tx.Begin();
await gtx.AddV("person").Property("name", "jorge").Promise(t => t.Iterate()).ConfigureAwait(false);
await gtx.AddV("person").Property("name", "josh").Promise(t => t.Iterate()).ConfigureAwait(false);
// Assert within the transaction
var count = await gtx.V().Count().Promise(t => t.Next()).ConfigureAwait(false);
Assert.Equal(2, count);
// Vertices should not be visible in a different transaction before commiting
count = await g.V().Count().Promise(t => t.Next()).ConfigureAwait(false);
Assert.Equal(0, count);
// Now commit changes to test outside of the transaction
await tx.CommitAsync().ConfigureAwait(false);
count = await g.V().Count().Promise(t => t.Next()).ConfigureAwait(false);
Assert.Equal(2, count);
}
public async Task ShouldThrowWhenModifyingTraversalSourceWithReadOnlyStrategy()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection).WithStrategies(new ReadOnlyStrategy());
await Assert.ThrowsAsync <ResponseException>(async() => await g.AddV("person").Promise(t => t.Next()));
}
public void ShouldThrowWhenGetIsCalledWithAnUnknownKey()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection);
var t = g.V().Iterate();
Assert.Throws <KeyNotFoundException>(() => t.SideEffects.Get("m"));
}
public void ShouldOnlyAllowChildTraversalsThatAreAnonymous()
{
var g = AnonymousTraversalSource.Traversal();
g.V(0).AddE("self").To(__.V(1));
Assert.Throws <ArgumentException>(() => g.V(0).AddE("self").To(g.V(1)));
}
public void ShouldUseTLabelInHasStep()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection);
var personsCount = g.V().Has(T.Label, "person").Count().Next();
Assert.Equal(4, personsCount);
}
public void ShouldUsePWithinInHasStep()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection);
var count = g.V().Has("name", P.Within("josh", "vadas")).Count().Next();
Assert.Equal(2, count);
}
public void g_VX1X_NextTraverser()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection);
var traverser = g.V(1).NextTraverser();
Assert.Equal(new Traverser(new Vertex(1)), traverser);
}
public async Task ShouldExecuteAsynchronouslyWhenPromiseIsCalled()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection);
var count = await g.V().Count().Promise(t => t.Next());
Assert.Equal(6, count);
}
public void g_VX1X_ToList()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection);
var list = g.V(1).ToList();
Assert.Equal(1, list.Count);
}
public void g_V_RepeatXBothX_TimesX5X_NextX10X()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection);
var result = g.V().Repeat(__.Both()).Times(5).Next(10);
Assert.Equal(10, result.Count());
}
public void ShouldThrowWhenGetIsCalledAfterDisposeAndNoSideEffectsAreCachec()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection);
var t = g.V().Aggregate("a").Iterate();
t.SideEffects.Dispose();
Assert.Throws <InvalidOperationException>(() => t.SideEffects.Get("a"));
}
public void g_V_Count()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection);
var count = g.V().Count().Next();
Assert.Equal(6, count);
}
public void ShouldBeIndependentFromReturnedGraphTraversalSourceModififyingTraversalStrategies()
{
var gLocal = AnonymousTraversalSource.Traversal();
var gRemote = gLocal.WithRemote(null);
Assert.Equal(0, gLocal.TraversalStrategies.Count);
Assert.Equal(1, gRemote.TraversalStrategies.Count);
}
public void ShouldUsePredicatesCombinedWithPAndInHasStep()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection);
var count = g.V().Has("age", P.Gt(30).And(P.Lt(35))).Count().Next();
Assert.Equal(1, count);
}
public void ShouldBeIndependentFromReturnedGraphTraversalModififyingBytecode()
{
var g = AnonymousTraversalSource.Traversal();
g.V().Has("someKey", "someValue").Drop();
Assert.Equal(0, g.Bytecode.StepInstructions.Count);
Assert.Equal(0, g.Bytecode.SourceInstructions.Count);
}
public async Task ShouldNotThrowWhenCloseIsCalledOnTraversalThatExecutedAsynchronously()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection);
var t = await g.V().Aggregate("a").Promise(x => x);
t.SideEffects.Close();
}
public void g_InjectX1_2_3X()
{
var g = AnonymousTraversalSource.Traversal();
var bytecode = g.Inject(1, 2, 3).Bytecode;
Assert.Equal(1, bytecode.StepInstructions.Count);
Assert.Equal("inject", bytecode.StepInstructions[0].OperatorName);
Assert.Equal(3, bytecode.StepInstructions[0].Arguments.Length);
}
public void ShouldReturnAnEmptyCollectionWhenKeysIsCalledForTraversalWithoutSideEffect()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection);
var t = g.V().Iterate();
var keys = t.SideEffects.Keys();
Assert.Equal(0, keys.Count);
}
public void ShouldNotSupportChildTransactions()
{
var g = AnonymousTraversalSource.Traversal()
.WithRemote(new DriverRemoteConnection(Mock.Of <IGremlinClient>()));
var tx = g.Tx();
var gtx = tx.Begin();
Assert.Throws <InvalidOperationException>(() => gtx.Tx());
}
public void ShouldNotAllowBeginMoreThanOnce()
{
var g = AnonymousTraversalSource.Traversal()
.WithRemote(new DriverRemoteConnection(Mock.Of <IGremlinClient>()));
var tx = g.Tx();
tx.Begin();
Assert.Throws <InvalidOperationException>(() => tx.Begin());
}
public void ShouldBeIndependentFromReturnedGraphTraversalSourceModififyingBytecode()
{
var g1 = AnonymousTraversalSource.Traversal();
var g2 = g1.WithSideEffect("someSideEffectKey", "someSideEffectValue");
Assert.Equal(0, g1.Bytecode.SourceInstructions.Count);
Assert.Equal(0, g1.Bytecode.StepInstructions.Count);
Assert.Equal(1, g2.Bytecode.SourceInstructions.Count);
}
public void ShouldHandleLambdasInWithSack()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection);
Assert.Equal(24.0, g.WithSack(1.0, (IUnaryOperator)Lambda.Groovy("x -> x + 1")).V().Both().Sack <double>().Sum <double>().Next());
Assert.Equal(24.0, g.WithSack((ISupplier)Lambda.Groovy("{1.0d}"), (IUnaryOperator)Lambda.Groovy("x -> x + 1")).V().Both().Sack <double>().Sum <double>().Next());
Assert.Equal(48.0, g.WithSack(1.0, (IBinaryOperator)Lambda.Groovy("x, y -> x + y + 1")).V().Both().Sack <double>().Sum <double>().Next());
Assert.Equal(48.0, g.WithSack((ISupplier)Lambda.Groovy("{1.0d}"), (IBinaryOperator)Lambda.Groovy("x, y -> x + y + 1")).V().Both().Sack <double>().Sum <double>().Next());
}
public void ShouldUseBindingsInTraversal()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection);
var b = new Bindings();
var count = g.V().Has(b.Of("propertyKey", "name"), b.Of("propertyValue", "marko")).OutE().Count().Next();
Assert.Equal(3, count);
}
public void GraphTraversalStepsShouldUnrollParamsParameters()
{
var g = AnonymousTraversalSource.Traversal();
var bytecode = g.V().HasLabel("firstLabel", "secondLabel", "thirdLabel").Bytecode;
Assert.Equal(0, bytecode.SourceInstructions.Count);
Assert.Equal(2, bytecode.StepInstructions.Count);
Assert.Equal(3, bytecode.StepInstructions[1].Arguments.Length);
}
public void g_VX1X_Next()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection);
var vertex = g.V(1).Next();
Assert.Equal(new Vertex(1), vertex);
Assert.Equal(1, vertex.Id);
}
public void g_V_Has_Count()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection);
var b = Bindings.Instance;
var count = g.V().Has("person", "age", b.Of("x", P.Lt(30))).Count().Next();
Assert.Equal(2, count);
}
public void g_V_Count_Next_WithVertexHasPropertySubgraphStrategy()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal()
.WithRemote(connection)
.WithStrategies(new SubgraphStrategy(vertices: __.Has("name", "marko")));
var count = g.V().Count().Next();
Assert.Equal(1, count);
}
public void ShouldIncludeOneStrategyInBytecodeWhenGivenToWithoutStrategies()
{
var g = AnonymousTraversalSource.Traversal();
var bytecode = g.WithoutStrategies(typeof(ReadOnlyStrategy)).Bytecode;
Assert.Single(bytecode.SourceInstructions);
Assert.Single(bytecode.SourceInstructions[0].Arguments);
Assert.Equal("withoutStrategies", bytecode.SourceInstructions[0].OperatorName);
Assert.Equal(typeof(ReadOnlyStrategy), bytecode.SourceInstructions[0].Arguments[0]);
}
public void ShortestPathTest()
{
var connection = _connectionFactory.CreateRemoteConnection();
var g = AnonymousTraversalSource.Traversal().WithRemote(connection);
var shortestPath =
g.V(5).Repeat(__.Both().SimplePath()).Until(__.HasId(6)).Limit <Vertex>(1).Path().Next();
Assert.Equal(4, shortestPath.Count);
Assert.Equal(new Vertex(6), shortestPath[3]);
}
