public GXAsyncWork(System.Windows.Forms.Control sender, AsyncStateChangeEventHandler e, AsyncTransaction command, object[] parameters)
{
OnAsyncStateChangeEventHandler = e;
Sender = sender;
Command = command;
Parameters = parameters;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <param name="command"></param>
/// <param name="error"></param>
/// <param name="text"></param>
/// <param name="parameters"></param>
public GXAsyncWork(object sender, AsyncStateChangeEventHandler e,
AsyncTransaction command, ErrorEventHandler error,
string text, object[] parameters)
{
OnError = error;
Text = text;
OnAsyncStateChangeEventHandler = e;
Sender = sender;
Command = command;
Parameters = parameters;
}
public async void ShouldCommitOnSuccess()
{
var protocol = new Mock <IBoltProtocol>();
var mockConn = NewMockedConnection(protocol.Object);
var mockHandler = new Mock <ITransactionResourceHandler>();
var tx = new AsyncTransaction(mockConn.Object, mockHandler.Object);
mockConn.Invocations.Clear();
await tx.CommitAsync();
protocol.Verify(x => x.CommitTransactionAsync(It.IsAny <IConnection>(), tx));
mockHandler.Verify(x => x.OnTransactionDisposeAsync(It.IsAny <Bookmark>()), Times.Once);
}
public void ShouldNotEnqueueMoreMessagesAfterMarkToClosedInRollbackAsync()
{
var protocol = new Mock <IBoltProtocol>();
var mockConn = NewMockedConnection(protocol.Object);
var tx = new AsyncTransaction(mockConn.Object, Mock.Of <ITransactionResourceHandler>());
mockConn.Invocations.Clear();
tx.MarkToClose();
tx.Awaiting(t => t.RollbackAsync()).Should().NotThrow();
protocol.Verify(x => x.RollbackTransactionAsync(It.IsAny <IConnection>()), Times.Never);
mockConn.Verify(x => x.SyncAsync(), Times.Never);
}
public async Task ShouldNotEnqueueMoreMessagesAfterMarkToClosedInRollbackAsync()
{
var protocol = new Mock <IBoltProtocol>();
var mockConn = NewMockedConnection(protocol.Object);
var tx = new AsyncTransaction(mockConn.Object);
mockConn.Invocations.Clear();
tx.MarkToClose();
await tx.RollbackAsync();
protocol.Verify(x => x.RollbackTransactionAsync(It.IsAny <IConnection>()), Times.Never);
mockConn.Verify(x => x.SyncAsync(), Times.Never);
}
public async Task ShouldNotDisposeIfAlreadyClosed()
{
var protocol = new Mock <IBoltProtocol>();
var mockConn = NewMockedConnection(protocol.Object);
var mockHandler = new Mock <ITransactionResourceHandler>();
var tx = new AsyncTransaction(mockConn.Object, mockHandler.Object);
mockConn.Invocations.Clear();
await tx.CommitAsync();
await tx.CloseAsync();
mockHandler.Verify(x => x.OnTransactionDisposeAsync(It.IsAny <Bookmark>()), Times.Once);
}
public async void ShouldThrowExceptionIfFailedToRunAndFetchResult()
{
var protocol = new Mock <IBoltProtocol>();
var mockConn = NewMockedConnection(protocol.Object);
var tx = new AsyncTransaction(mockConn.Object);
var statement = new Statement("lala");
protocol.Setup(x => x.RunInExplicitTransactionAsync(It.IsAny <IConnection>(), statement, false))
.Throws <Neo4jException>();
var error = await ExceptionAsync(() => tx.RunAsync(statement));
error.Should().BeOfType <Neo4jException>();
}
public void ShouldNotEnqueueMoreMessagesAfterMarkToClosedInCommitAsync()
{
var protocol = new Mock <IBoltProtocol>();
var mockConn = NewMockedConnection(protocol.Object);
var tx = new AsyncTransaction(mockConn.Object, Mock.Of <ITransactionResourceHandler>());
mockConn.Invocations.Clear();
tx.MarkToClose();
tx.Awaiting(t => t.CommitAsync()).Should().Throw <ClientException>().Which.Message.Should()
.Contain("Cannot commit this transaction");
protocol.Verify(x => x.CommitTransactionAsync(It.IsAny <IConnection>(), tx), Times.Never);
mockConn.Verify(x => x.SyncAsync(), Times.Never);
}
public async void ShouldThrowExceptionIfFailedToRunAndFetchResult()
{
var protocol = new Mock <IBoltProtocol>();
var mockConn = NewMockedConnection(protocol.Object);
var tx = new AsyncTransaction(mockConn.Object, Mock.Of <ITransactionResourceHandler>());
var query = new Query("lala");
protocol.Setup(x => x.RunInExplicitTransactionAsync(It.IsAny <IConnection>(), query, false, It.IsAny <long>()))
.Throws <Neo4jException>();
var error = await ExceptionAsync(() => tx.RunAsync(query));
error.Should().BeOfType <Neo4jException>();
}
public void ShouldThrowExceptionToRunAfterMarkToClosed()
{
var protocol = new Mock <IBoltProtocol>();
var mockConn = NewMockedConnection(protocol.Object);
var tx = new AsyncTransaction(mockConn.Object, Mock.Of <ITransactionResourceHandler>());
mockConn.Invocations.Clear();
tx.MarkToClose();
tx.Awaiting(t => t.RunAsync("should not run")).Should().Throw <ClientException>().Which.Message.Should()
.StartWith("Cannot run statement in this transaction");
protocol.Verify(x => x.RollbackTransactionAsync(It.IsAny <IConnection>()), Times.Never);
mockConn.Verify(x => x.SyncAsync(), Times.Never);
}
public async Task ShouldSaveBookmark()
{
var mockConn = new Mock <IConnection>();
var mockProtocol = new Mock <IBoltProtocol>();
mockConn.Setup(x => x.BoltProtocol).Returns(mockProtocol.Object);
var bookmark = Bookmark.From(FakeABookmark(123));
var tx = new AsyncTransaction(mockConn.Object, null, null, bookmark);
await tx.BeginTransactionAsync(null);
mockProtocol.Verify(
x => x.BeginTransactionAsync(It.IsAny <IConnection>(), bookmark, It.IsAny <TransactionConfig>()),
Times.Once);
}
public async Task ShouldThrowExceptionToRunAfterMarkToClosed()
{
var protocol = new Mock <IBoltProtocol>();
var mockConn = NewMockedConnection(protocol.Object);
var tx = new AsyncTransaction(mockConn.Object);
mockConn.Invocations.Clear();
tx.MarkToClose();
var exception = await Record.ExceptionAsync(() => tx.RunAsync("should not run"));
exception.Should().BeOfType <ClientException>();
exception.Message.Should().StartWith("Cannot run more statements in this transaction");
protocol.Verify(x => x.RollbackTransactionAsync(It.IsAny <IConnection>()), Times.Never);
mockConn.Verify(x => x.SyncAsync(), Times.Never);
}
public async Task TestAsyncListTableNamesLists()
{
var factory = new ValueFactory();
var tables = new List <string> {
"table1", "table2"
};
var ions = tables.Select(t => CreateValueHolder(factory.NewString(t))).ToList();
var h1 = QldbHash.ToQldbHash(TestTransactionId);
h1 = AsyncTransaction.Dot(h1, QldbDriverBase <AsyncQldbSession> .TableNameQuery, new List <IIonValue>());
mockClient.QueueResponse(StartSessionResponse(TestRequestId));
mockClient.QueueResponse(StartTransactionResponse(TestTransactionId, TestRequestId));
mockClient.QueueResponse(ExecuteResponse(TestRequestId, ions));
mockClient.QueueResponse(CommitResponse(TestTransactionId, TestRequestId, h1.Hash));
var result = await testDriver.ListTableNames();
Assert.IsNotNull(result);
CollectionAssert.AreEqual(tables, result.ToList());
mockClient.Clear();
}
public GXAsyncWork(System.Windows.Forms.Control sender, AsyncStateChangeEventHandler e, AsyncTransaction command, object[] parameters)
{
OnAsyncStateChangeEventHandler = e;
Sender = sender;
Command = command;
Parameters = parameters;
}
public void SetUp()
{
mockSession = new Mock <Session>(null, null, null, null, null);
asyncTransaction = new AsyncTransaction(mockSession.Object, TxnId, mockLogger.Object,
It.IsAny <CancellationToken>());
}
