public async Task ShouldPassBookmarkAndTxConfigToRunWithMetadataMessage(AccessMode mode)
{
var mockConn = NewConnectionWithMode(mode);
var statement = new Statement("A cypher query");
var bookmarkTracker = new Mock <IBookmarkTracker>();
var resourceHandler = new Mock <IResultResourceHandler>();
mockConn.Setup(x => x.EnqueueAsync(It.IsAny <RunMessage>(), It.IsAny <V3.RunResponseHandler>(),
It.IsAny <PullAllMessage>(), It.IsAny <V3.PullResponseHandler>()))
.Returns(TaskHelper.GetCompletedTask())
.Callback <IRequestMessage, IResponseHandler, IRequestMessage, IResponseHandler>(
(m1, h1, m2, h2) =>
{
h1.OnSuccess(new Dictionary <string, object>());
VerifyMetadata(m1.CastOrThrow <RunWithMetadataMessage>().Metadata, mode);
});
await BoltV3.RunInAutoCommitTransactionAsync(mockConn.Object, statement, true, bookmarkTracker.Object,
resourceHandler.Object, Bookmark, TxConfig);
mockConn.Verify(
x => x.EnqueueAsync(It.IsAny <RunWithMetadataMessage>(), It.IsAny <V3.RunResponseHandler>(),
PullAllMessage.PullAll,
It.IsAny <V3.PullResponseHandler>()),
Times.Once);
}
public async Task ShouldNotSyncIfBookmarkIsNull()
{
var mockConn = new Mock <IConnection>();
await BoltV3.BeginTransactionAsync(mockConn.Object, null, null);
mockConn.Verify(x => x.Enqueue(It.IsAny <BeginMessage>(), It.IsAny <IMessageResponseCollector>(), null), Times.Once);
mockConn.Verify(x => x.SyncAsync(), Times.Never);
}
public async Task EnqueueCommitAndSync()
{
var mockConn = new Mock <IConnection>();
await BoltV3.CommitTransactionAsync(mockConn.Object);
mockConn.Verify(x => x.Enqueue(Commit, It.IsAny <BookmarkCollector>(), null), Times.Once);
mockConn.Verify(x => x.SyncAsync(), Times.Once);
}
public void ResultBuilderShouldObtainServerInfoFromConnection()
{
var mockConn = new Mock <IConnection>();
var statement = new Statement("lalala");
BoltV3.RunInExplicitTransaction(mockConn.Object, statement);
mockConn.Verify(x => x.Server, Times.Once);
}
public void ShouldThrowWhenADatabaseIsGiven(string database)
{
BoltV3.Awaiting(p => p.RunInAutoCommitTransactionAsync(Mock.Of <IConnection>(), new Query("text"),
false, Mock.Of <IBookmarkTracker>(), Mock.Of <IResultResourceHandler>(), database,
Bookmark.From("123"),
TransactionConfig.Default))
.Should().Throw <ClientException>().WithMessage("*that does not support multiple databases*");
}
public async Task ShouldEnqueueGoodbyeAndSend()
{
var mockConn = new Mock <IConnection>();
await BoltV3.LogoutAsync(mockConn.Object);
mockConn.Verify(x => x.Enqueue(It.IsAny <GoodbyeMessage>(), null, null), Times.Once);
mockConn.Verify(x => x.SendAsync());
}
public async Task ShouldSyncIfValidBookmarkGiven()
{
var mockConn = new Mock <IConnection>();
var bookmark = Bookmark.From(FakeABookmark(234));
await BoltV3.BeginTransactionAsync(mockConn.Object, bookmark, null);
mockConn.Verify(x => x.Enqueue(It.IsAny <BeginMessage>(), It.IsAny <IMessageResponseCollector>(), null), Times.Once);
mockConn.Verify(x => x.SyncAsync(), Times.Once);
}
public async Task ResultBuilderShouldObtainServerInfoFromConnection()
{
var mockConn = SessionTests.MockedConnectionWithSuccessResponse();
var statement = new Statement("lalala");
await BoltV3.RunInExplicitTransactionAsync(mockConn.Object, statement, true);
mockConn.Verify(x => x.Server, Times.Once);
}
public void ShouldEnqueueRollbackAndSync()
{
var mockConn = new Mock <IConnection>();
BoltV3.RollbackTransactionAsync(mockConn.Object);
mockConn.Verify(x => x.Enqueue(Rollback, It.IsAny <BookmarkCollector>(), null), Times.Once);
mockConn.Verify(x => x.SyncAsync(), Times.Once);
}
public void ResultBuilderShouldObtainServerInfoFromConnection()
{
var mockConn = new Mock <IConnection>();
var statement = new Statement("A cypher query");
var mockHandler = new Mock <IResultResourceHandler>();
BoltV3.RunInAutoCommitTransaction(mockConn.Object, statement, mockHandler.Object, null, null);
mockConn.Verify(x => x.Server, Times.Once);
}
public void ShouldNotSyncIfInvalidBookmarkGiven()
{
var mockConn = new Mock <IConnection>();
var bookmark = Bookmark.From((string)null);
BoltV3.BeginTransaction(mockConn.Object, bookmark, null);
mockConn.Verify(x => x.Enqueue(It.IsAny <BeginMessage>(), It.IsAny <IMessageResponseCollector>(), null), Times.Once);
mockConn.Verify(x => x.Sync(), Times.Never);
}
public async Task ShouldRunPullAllSync()
{
var mockConn = MockedConnectionWithSuccessResponse();
var statement = new Statement("lalala");
await BoltV3.RunInExplicitTransactionAsync(mockConn.Object, statement);
mockConn.Verify(x => x.Enqueue(It.IsAny <RunWithMetadataMessage>(), It.IsAny <ResultCursorBuilder>(), PullAll), Times.Once);
mockConn.Verify(x => x.SendAsync(), Times.Once);
}
public void ShouldRunPullAllSync()
{
var mockConn = new Mock <IConnection>();
var statement = new Statement("lalala");
BoltV3.RunInExplicitTransaction(mockConn.Object, statement);
mockConn.Verify(x => x.Enqueue(It.IsAny <RunWithMetadataMessage>(), It.IsAny <ResultBuilder>(), PullAll), Times.Once);
mockConn.Verify(x => x.Send(), Times.Once);
}
public async Task ShouldNotSyncIfBookmarkIsNull()
{
var mockConn = NewConnectionWithMode();
await BoltV3.BeginTransactionAsync(mockConn.Object, null, null);
mockConn.Verify(
x => x.EnqueueAsync(It.IsAny <BeginMessage>(), It.IsAny <V1.BeginResponseHandler>(), null, null),
Times.Once);
mockConn.Verify(x => x.SyncAsync(), Times.Never);
}
public async Task ShouldEnqueueRollbackAndSync()
{
var mockConn = NewConnectionWithMode();
await BoltV3.RollbackTransactionAsync(mockConn.Object);
mockConn.Verify(
x => x.EnqueueAsync(RollbackMessage.Rollback, It.IsAny <V1.RollbackResponseHandler>(), null, null),
Times.Once);
mockConn.Verify(x => x.SyncAsync(), Times.Once);
}
public void ShouldEnqueueRunAndPullAllAndSend()
{
var mockConn = new Mock <IConnection>();
var statement = new Statement("A cypher query");
var mockHandler = new Mock <IResultResourceHandler>();
BoltV3.RunInAutoCommitTransaction(mockConn.Object, statement, mockHandler.Object, null, null);
mockConn.Verify(x => x.Enqueue(It.IsAny <RunWithMetadataMessage>(), It.IsAny <ResultBuilder>(), PullAll), Times.Once);
mockConn.Verify(x => x.Send());
}
public async Task ShouldEnqueueHelloAndSync()
{
var mockConn = new Mock <IConnection>();
mockConn.Setup(x => x.Server).Returns(new ServerInfo(new Uri("http://neo4j.com")));
await BoltV3.LoginAsync(mockConn.Object, "user-zhen", AuthTokens.None);
mockConn.Verify(x => x.Enqueue(It.IsAny <HelloMessage>(), It.IsAny <ServerVersionCollector>(), null), Times.Once);
mockConn.Verify(x => x.SyncAsync());
mockConn.Verify(x => x.UpdateId(It.IsAny <string>()));
}
public async Task ShouldSyncIfValidBookmarkGiven()
{
var mockConn = NewConnectionWithMode();
var bookmark = Bookmark.From(SessionTests.FakeABookmark(234));
await BoltV3.BeginTransactionAsync(mockConn.Object, bookmark, null);
mockConn.Verify(
x => x.EnqueueAsync(It.IsAny <BeginMessage>(), It.IsAny <V1.BeginResponseHandler>(), null, null),
Times.Once);
mockConn.Verify(x => x.SyncAsync(), Times.Once);
}
public async Task EnqueueCommitAndSync()
{
var mockConn = NewConnectionWithMode();
var bookmarkTracker = new Mock <IBookmarkTracker>();
await BoltV3.CommitTransactionAsync(mockConn.Object, bookmarkTracker.Object);
mockConn.Verify(
x => x.EnqueueAsync(CommitMessage.Commit, It.IsAny <V1.CommitResponseHandler>(), null, null),
Times.Once);
mockConn.Verify(x => x.SyncAsync(), Times.Once);
}
public async Task ShouldNotSyncIfInvalidBookmarkGiven()
{
var mockConn = NewConnectionWithMode();
var bookmark = Bookmark.From((string)null);
await BoltV3.BeginTransactionAsync(mockConn.Object, bookmark, null);
mockConn.Verify(
x => x.EnqueueAsync(It.IsAny <BeginMessage>(), It.IsAny <V1.BeginResponseHandler>(), null, null),
Times.Once);
mockConn.Verify(x => x.SyncAsync(), Times.Never);
}
public async Task ShouldRunPullAllSync()
{
var mockConn = SessionTests.MockedConnectionWithSuccessResponse();
var statement = new Statement("lalala");
await BoltV3.RunInExplicitTransactionAsync(mockConn.Object, statement, true);
mockConn.Verify(
x => x.EnqueueAsync(It.IsAny <RunWithMetadataMessage>(), It.IsAny <V3.RunResponseHandler>(),
PullAllMessage.PullAll,
It.IsAny <V3.PullResponseHandler>()),
Times.Once);
mockConn.Verify(x => x.SendAsync(), Times.Once);
}
public async Task ShouldPassBookmarkAndTxConfigToRunWithMetadataMessage()
{
var mockConn = new Mock <IConnection>();
mockConn.Setup(x => x.Enqueue(It.IsAny <BeginMessage>(), It.IsAny <ResultBuilder>(), null))
.Callback <IRequestMessage, IMessageResponseCollector, IRequestMessage>(
(m0, r, m1) =>
{
var msg = m0.CastOrThrow <BeginMessage>();
VerifyMetadata(msg.Metadata);
});
await BoltV3.BeginTransactionAsync(mockConn.Object, Bookmark, TxConfig);
mockConn.Verify(x => x.Enqueue(It.IsAny <BeginMessage>(), It.IsAny <ResultBuilder>(), null), Times.Once);
}
public async Task ResultBuilderShouldObtainServerInfoFromConnection()
{
var mockConn = new Mock <IConnection>();
var statement = new Statement("A cypher query");
var mockHandler = new Mock <IResultResourceHandler>();
mockConn.Setup(x => x.Enqueue(It.IsAny <IRequestMessage>(), It.IsAny <ResultCursorBuilder>(), PullAll))
.Callback <IRequestMessage, IMessageResponseCollector, IRequestMessage>(
(msg1, h, msg2) =>
{
h?.DoneSuccess();
});
await BoltV3.RunInAutoCommitTransactionAsync(mockConn.Object, statement, mockHandler.Object, null, null);
mockConn.Verify(x => x.Server, Times.Once);
}
public async Task ResultBuilderShouldObtainServerInfoFromConnection()
{
var mockConn = NewConnectionWithMode();
var statement = new Statement("A cypher query");
var bookmarkTracker = new Mock <IBookmarkTracker>();
var resourceHandler = new Mock <IResultResourceHandler>();
mockConn.Setup(x => x.EnqueueAsync(It.IsAny <RunMessage>(), It.IsAny <V3.RunResponseHandler>(),
It.IsAny <PullAllMessage>(), It.IsAny <V3.PullResponseHandler>()))
.Returns(TaskHelper.GetCompletedTask())
.Callback <IRequestMessage, IResponseHandler, IRequestMessage, IResponseHandler>(
(msg1, h1, msg2, h2) => { h1.OnSuccess(new Dictionary <string, object>()); });
await BoltV3.RunInAutoCommitTransactionAsync(mockConn.Object, statement, true, bookmarkTracker.Object,
resourceHandler.Object, null, null);
mockConn.Verify(x => x.Server, Times.Once);
}
public async Task ShouldPassBookmarkAndTxConfigToRunWithMetadataMessage()
{
var mockConn = new Mock <IConnection>();
var statement = new Statement("A cypher query");
var mockHandler = new Mock <IResultResourceHandler>();
mockConn.Setup(x => x.Enqueue(It.IsAny <IRequestMessage>(), It.IsAny <ResultCursorBuilder>(), PullAll))
.Callback <IRequestMessage, IMessageResponseCollector, IRequestMessage>(
(m0, h, m1) =>
{
h?.DoneSuccess();
VerifyMetadata(m0.CastOrThrow <RunWithMetadataMessage>().Metadata);
});
await BoltV3.RunInAutoCommitTransactionAsync(mockConn.Object, statement, mockHandler.Object,
Bookmark, TxConfig);
mockConn.Verify(x => x.Enqueue(It.IsAny <RunWithMetadataMessage>(), It.IsAny <ResultCursorBuilder>(), PullAll), Times.Once);
}
public async Task ShouldPassBookmarkTxConfigAndModeToRunWithMetadataMessage(AccessMode mode)
{
var mockConn = NewConnectionWithMode(mode);
mockConn.Setup(x =>
x.EnqueueAsync(It.IsAny <BeginMessage>(), It.IsAny <V1.BeginResponseHandler>(), null, null))
.Returns(TaskHelper.GetCompletedTask())
.Callback <IRequestMessage, IResponseHandler, IRequestMessage, IResponseHandler>(
(m1, h1, m2, h2) =>
{
var msg = m1.CastOrThrow <BeginMessage>();
VerifyMetadata(msg.Metadata, mode);
});
await BoltV3.BeginTransactionAsync(mockConn.Object, Bookmark, TxConfig);
mockConn.Verify(
x => x.EnqueueAsync(It.IsAny <BeginMessage>(), It.IsAny <V1.BeginResponseHandler>(), null, null),
Times.Once);
}
public async Task ShouldEnqueueRunAndPullAllAndSend()
{
var mockConn = NewConnectionWithMode();
var query = new Query("A cypher query");
var bookmarkTracker = new Mock <IBookmarkTracker>();
var resourceHandler = new Mock <IResultResourceHandler>();
mockConn.Setup(x => x.EnqueueAsync(It.IsAny <IRequestMessage>(), It.IsAny <IResponseHandler>(),
It.IsAny <IRequestMessage>(), It.IsAny <IResponseHandler>()))
.Returns(Task.CompletedTask)
.Callback <IRequestMessage, IResponseHandler, IRequestMessage, IResponseHandler>(
(msg1, h1, msg2, h2) => { h1.OnSuccess(new Dictionary <string, object>()); });
await BoltV3.RunInAutoCommitTransactionAsync(mockConn.Object, query, true, bookmarkTracker.Object,
resourceHandler.Object, null, null, null);
mockConn.Verify(
x => x.EnqueueAsync(It.IsAny <RunWithMetadataMessage>(), It.IsAny <V3.RunResponseHandler>(),
PullAllMessage.PullAll,
It.IsAny <V3.PullResponseHandler>()), Times.Once);
mockConn.Verify(x => x.SendAsync());
}
public void ShouldThrowWhenADatabaseIsGiven(string database)
{
BoltV3.Awaiting(p => p.BeginTransactionAsync(Mock.Of <IConnection>(), database, Bookmark.From("123"),
TransactionConfig.Default))
.Should().Throw <ClientException>().WithMessage("*that does not support multiple databases*");
}
