private void CreateDriverFactory()
{
_driverFactory = new Lazy <IQldbDriver>(() =>
{
var builder = QldbDriver.Builder()
.WithAWSCredentials(_credentials)
.WithQLDBSessionConfig(_sessionConfig);
if (!string.IsNullOrEmpty(_ledger))
{
builder.WithLedger(_ledger);
}
if (_maxConcurrentTransactions >= 0)
{
builder.WithMaxConcurrentTransactions(_maxConcurrentTransactions);
}
if (_useRetryLogging)
{
builder.WithRetryLogging();
}
if (_logger != null)
{
builder.WithLogger(_logger);
}
return(builder
.Build());
});
}
public async Task TestExecuteWithActionLambdaCanInvokeSuccessfully()
{
var driver = new QldbDriver(
new SessionPool(() => Session.StartSession("ledgerName", mockClient.Object, NullLogger.Instance),
new Mock <IRetryHandler>().Object, 4, NullLogger.Instance));
await driver.Execute(txn => txn.Execute("testStatement"));
}
public QldbDriver CreateDriver(
AmazonQLDBSessionConfig amazonQldbSessionConfig,
int maxConcurrentTransactions = default,
string ledgerName = default)
{
QldbDriverBuilder builder = QldbDriver.Builder();
string finalLedgerName;
if (ledgerName != default)
{
finalLedgerName = ledgerName;
}
else
{
finalLedgerName = this.ledgerName;
}
if (maxConcurrentTransactions != default)
{
builder.WithMaxConcurrentTransactions(maxConcurrentTransactions);
}
return(builder.WithQLDBSessionConfig(amazonQldbSessionConfig)
.WithLedger(finalLedgerName)
.Build());
}
public void TestDisposeWithRepeatCalls()
{
var driver = new QldbDriver("ledgerName", mockClient.Object, 4, NullLogger.Instance);
driver.Dispose();
driver.Dispose();
}
public void TestQldbDriverConstructorReturnsValidObject()
{
var driver = new QldbDriver(
new SessionPool(() => Session.StartSession("ledgerName", mockClient.Object, NullLogger.Instance),
new Mock <IRetryHandler>().Object, 4, NullLogger.Instance));
Assert.IsNotNull(driver);
}
public async Task TestExecuteWithActionLambdaAndRetryPolicyCanInvokeSuccessfully()
{
var driver = new QldbDriver(
new SessionPool(() => Session.StartSession("ledgerName", mockClient.Object, NullLogger.Instance),
QldbDriverBuilder.CreateDefaultRetryHandler(NullLogger.Instance), 4, NullLogger.Instance));
await driver.Execute(txn => txn.Execute("testStatement"), Driver.RetryPolicy.Builder().Build());
}
public void TestGetSession_GetTwoSessionsFromPoolOfOne_TimeoutOnSecondGet()
{
var driver = new QldbDriver(TestLedger, mockClient, 1, NullLogger.Instance);
QldbSession returnedSession = driver.GetSession();
Assert.ThrowsException <QldbDriverException>(() => driver.GetSession());
Assert.IsNotNull(returnedSession);
}
public QldbService()
{
AmazonQLDBSessionConfig amazonQldbSessionConfig = new AmazonQLDBSessionConfig();
this.driver = QldbDriver.Builder()
.WithQLDBSessionConfig(amazonQldbSessionConfig)
.WithLedger(LedgerName)
.Build();
}
private AmazonQldbDataProvider GetAmazonQLDBDataProvider(List <AuditEvent> ins, List <AuditEvent> repl) =>
new AmazonQldbDataProviderForTest(ins, repl)
{
QldbDriver = new Lazy <IQldbDriver>(() => QldbDriver.Builder()
.WithQLDBSessionConfig(new AmazonQLDBSessionConfig())
.WithLedger("audit-ledger")
.WithRetryLogging()
.WithMaxConcurrentTransactions(2)
.Build()),
TableNameBuilder = ev => ev.EventType
};
public void TestExecuteWithActionAndRetryActionCanInvokeSuccessfully()
{
var driver = new QldbDriver(
new SessionPool(() => Session.StartSession("ledgerName", mockClient.Object, NullLogger.Instance),
QldbDriverBuilder.CreateDefaultRetryHandler(NullLogger.Instance), 4, NullLogger.Instance));
driver.Execute((txn) =>
{
txn.Execute("testStatement");
},
Console.WriteLine);
}
public void TestExecuteWithFuncLambdaAndRetryActionReturnsFuncOutput()
{
var driver = new QldbDriver(
new SessionPool(() => Session.StartSession("ledgerName", mockClient.Object, NullLogger.Instance),
QldbDriverBuilder.CreateDefaultRetryHandler(NullLogger.Instance), 4, NullLogger.Instance));
driver.Dispose();
Assert.ThrowsException <QldbDriverException>(() => driver.Execute((txn) =>
{
txn.Execute("testStatement");
return("testReturnValue");
}, Console.WriteLine));
}
public async Task TestExecuteWithFuncLambdaReturnsFuncOutput()
{
var driver = new QldbDriver(
new SessionPool(() => Session.StartSession("ledgerName", mockClient.Object, NullLogger.Instance),
QldbDriverBuilder.CreateDefaultRetryHandler(NullLogger.Instance), 4, NullLogger.Instance));
var result = await driver.Execute(async txn =>
{
await txn.Execute("testStatement");
return("testReturnValue");
});
Assert.AreEqual("testReturnValue", result);
}
public async Task TestExecuteWithFuncLambdaAndRetryPolicyReturnsFuncOutput()
{
var driver = new QldbDriver(
new SessionPool(() => Session.StartSession("ledgerName", mockClient.Object, NullLogger.Instance),
QldbDriverBuilder.CreateDefaultRetryHandler(NullLogger.Instance), 4, NullLogger.Instance));
await driver.DisposeAsync();
await Assert.ThrowsExceptionAsync <QldbDriverException>(async() => await driver.Execute(async txn =>
{
await txn.Execute("testStatement");
return("testReturnValue");
}, Driver.RetryPolicy.Builder().Build()));
}
public void TestWithLedgerValidAndInvalidInputs()
{
var testBuilder = QldbDriver.Builder();
QldbDriver driver;
// No specified ledger
Assert.ThrowsException <ArgumentException>(() => driver = testBuilder.Build());
// Empty ledger
Assert.ThrowsException <ArgumentException>(() => testBuilder.WithLedger(""));
Assert.ThrowsException <ArgumentException>(() => testBuilder.WithLedger(null));
driver = testBuilder.WithLedger("testLedger").Build();
Assert.IsNotNull(driver);
}
public void TestGetSessionGetsANewSession()
{
var driver = new QldbDriver("ledgerName", mockClient.Object, 4, NullLogger.Instance);
var session1 = driver.GetSession();
Assert.IsNotNull(session1);
var session2 = driver.GetSession();
Assert.IsNotNull(session2);
Assert.AreNotEqual(session1, session2);
driver.Dispose();
Assert.ThrowsException <ObjectDisposedException>(() => driver.GetSession());
}
public void SetupTest()
{
builder = QldbDriver.Builder()
.WithLedger("testLedger")
.WithRetryLogging()
.WithLogger(NullLogger.Instance)
.WithAWSCredentials(new Mock <AWSCredentials>().Object)
.WithQLDBSessionConfig(new AmazonQLDBSessionConfig());
Assert.IsNotNull(builder);
mockClient = new MockSessionClient();
mockClient.SetDefaultResponse(DefaultSendCommandResponse("testToken", TestTransactionId,
TestRequestId, digest));
testDriver = new QldbDriver(TestLedger, mockClient, 4, NullLogger.Instance);
Assert.IsNotNull(testDriver);
}
public void SetupTest()
{
mockClient = new Mock <AmazonQLDBSessionClient>();
var sendCommandResponse = new SendCommandResponse
{
StartSession = new StartSessionResult
{
SessionToken = "testToken"
},
StartTransaction = new StartTransactionResult
{
TransactionId = "testTransactionIdddddd"
},
ExecuteStatement = new ExecuteStatementResult
{
FirstPage = new Page
{
NextPageToken = null,
Values = new List <ValueHolder>()
}
},
CommitTransaction = new CommitTransactionResult
{
CommitDigest = new MemoryStream(digest)
},
ResponseMetadata = new ResponseMetadata
{
RequestId = "testId"
}
};
mockClient.Setup(x => x.SendCommandAsync(It.IsAny <SendCommandRequest>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(sendCommandResponse));
builder = QldbDriver.Builder()
.WithLedger("testLedger")
.WithRetryLogging()
.WithLogger(NullLogger.Instance)
.WithAWSCredentials(new Mock <AWSCredentials>().Object)
.WithQLDBSessionConfig(new AmazonQLDBSessionConfig());
}
public static async Task Main(string[] args)
{
Audit.EntityFramework.Configuration.Setup()
.ForContext <InvoicingContext>(config => config
.IncludeEntityObjects()
.AuditEventType("{context}:{database}"));
Audit.Core.Configuration.Setup()
.UseAmazonQldb(config => config.WithQldbDriver(QldbDriver.Builder()
.WithLedger("InvoicingSystem")
.Build())
.Table("AuditEvents"));
var host = CreateWebHostBuilder(args).Build();
await host.RunAsync();
Audit.Core.Configuration
.AddCustomAction(ActionType.OnEventSaving, scope =>
{
var httpContextAccessor = (IHttpContextAccessor)host.Services.GetService(typeof(IHttpContextAccessor));
scope.SetCustomField("TraceId", httpContextAccessor.HttpContext.TraceIdentifier);
});
}
public static void SetUp(TestContext context)
{
// Get AWS configuration properties from .runsettings file.
string region = context.Properties["region"].ToString();
const string ledgerName = "DotnetStatementExecution";
amazonQldbSessionConfig = IntegrationTestBase.CreateAmazonQLDBSessionConfig(region);
integrationTestBase = new IntegrationTestBase(ledgerName, region);
integrationTestBase.RunForceDeleteLedger();
integrationTestBase.RunCreateLedger();
qldbDriver = integrationTestBase.CreateDriver(amazonQldbSessionConfig, new ObjectSerializer());
// Create table.
var query = $"CREATE TABLE {Constants.TableName}";
var count = qldbDriver.Execute(txn =>
{
var result = txn.Execute(query);
var count = 0;
foreach (var row in result)
{
count++;
}
return(count);
});
Assert.AreEqual(1, count);
var result = qldbDriver.ListTableNames();
foreach (var row in result)
{
Assert.AreEqual(Constants.TableName, row);
}
}
public static async Task SetUp(TestContext context)
{
// Get AWS configuration properties from .runsettings file.
string region = context.Properties["region"].ToString();
amazonQldbSessionConfig = IntegrationTestBase.CreateAmazonQLDBSessionConfig(region);
integrationTestBase = new IntegrationTestBase(Constants.LedgerName, region);
integrationTestBase.RunForceDeleteLedger();
integrationTestBase.RunCreateLedger();
qldbDriver = integrationTestBase.CreateDriver(amazonQldbSessionConfig);
// Create table.
var query = $"CREATE TABLE {Constants.TableName}";
var count = await qldbDriver.Execute(async txn =>
{
var result = await txn.Execute(query);
var count = 0;
await foreach (var row in result)
{
count++;
}
return(count);
});
Assert.AreEqual(1, count);
var result = await qldbDriver.ListTableNames();
foreach (var row in result)
{
Assert.AreEqual(Constants.TableName, row);
}
}
/// <summary>
/// Creates a new AmazonQLDB data provider using the given driver.
/// </summary>
/// <param name="driver">The Amazon QLDB driver instance.</param>
public AmazonQldbDataProvider(QldbDriver driver)
{
QldbDriver = new Lazy <IQldbDriver>(() => driver);
}
public async Task Execute_ExceptionOnExecute_ShouldOnlyRetryOnISEAndTAOE(Exception exception, bool expectThrow)
{
var statement = "DELETE FROM table;";
var h1 = QldbHash.ToQldbHash(TestTransactionId);
h1 = Transaction.Dot(h1, statement, new List <IIonValue> {
});
var sendCommandResponseWithStartSession = new SendCommandResponse
{
StartTransaction = new StartTransactionResult
{
TransactionId = TestTransactionId
},
ResponseMetadata = new ResponseMetadata
{
RequestId = "testId"
}
};
var sendCommandResponseExecute = new SendCommandResponse
{
ExecuteStatement = new ExecuteStatementResult
{
FirstPage = new Page
{
NextPageToken = null
}
},
ResponseMetadata = new ResponseMetadata
{
RequestId = "testId"
}
};
var sendCommandResponseCommit = new SendCommandResponse
{
CommitTransaction = new CommitTransactionResult
{
TransactionId = TestTransactionId,
CommitDigest = new MemoryStream(h1.Hash),
},
ResponseMetadata = new ResponseMetadata
{
RequestId = "testId"
}
};
var mockCreator = new Mock <Func <Task <Session> > >();
var mockSession = new Mock <Session>(null, null, null, null, null);
mockSession.Setup(x => x.StartTransaction(It.IsAny <CancellationToken>())).ReturnsAsync(sendCommandResponseWithStartSession.StartTransaction);
mockSession.SetupSequence(x => x.ExecuteStatement(It.IsAny <String>(), It.IsAny <String>(), It.IsAny <List <IIonValue> >(), It.IsAny <CancellationToken>()))
.ThrowsAsync(exception)
.ThrowsAsync(exception)
.ReturnsAsync(sendCommandResponseExecute.ExecuteStatement);
mockSession.Setup(x => x.CommitTransaction(It.IsAny <String>(), It.IsAny <MemoryStream>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(sendCommandResponseCommit.CommitTransaction);
mockCreator.Setup(x => x()).ReturnsAsync(mockSession.Object);
var driver = new QldbDriver(
new SessionPool(mockCreator.Object, QldbDriverBuilder.CreateDefaultRetryHandler(NullLogger.Instance), 4, NullLogger.Instance));
try
{
await driver.Execute(txn => txn.Execute(statement));
}
catch (Exception e)
{
Assert.AreEqual(exception, e);
Assert.IsTrue(expectThrow);
return;
}
Assert.IsFalse(expectThrow);
}
public void TestQldbDriverConstructorReturnsValidObject()
{
var driver = new QldbDriver("ledgerName", mockClient.Object, 4, NullLogger.Instance);
Assert.IsNotNull(driver);
}
public void SetupTest()
{
builder = QldbDriver.Builder().WithLedger("testLedger");
}
public void Execute_UpdateSameRecordAtSameTime_ThrowsOccException()
{
QldbDriver driver = integrationTestBase.CreateDriver(amazonQldbSessionConfig, default, default, 0);
public IAmazonQldbProviderTableConfigurator WithQldbDriver(QldbDriver driver)
{
_driverFactory = new Lazy <IQldbDriver>(() => driver);
return(_tableConfigurator);
}
public async Task TestListTableNamesLists()
{
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 = Transaction.Dot(h1, QldbDriver.TableNameQuery, new List <IIonValue> {
});
var sendCommandResponseWithStartSession = new SendCommandResponse
{
StartSession = new StartSessionResult
{
SessionToken = "testToken"
},
ResponseMetadata = new ResponseMetadata
{
RequestId = "testId"
}
};
var sendCommandResponseStartTransaction = new SendCommandResponse
{
StartTransaction = new StartTransactionResult
{
TransactionId = TestTransactionId
},
ResponseMetadata = new ResponseMetadata
{
RequestId = "testId"
}
};
var sendCommandResponseExecute = new SendCommandResponse
{
ExecuteStatement = new ExecuteStatementResult
{
FirstPage = new Page
{
NextPageToken = null,
Values = ions
}
},
ResponseMetadata = new ResponseMetadata
{
RequestId = "testId"
}
};
var sendCommandResponseCommit = new SendCommandResponse
{
CommitTransaction = new CommitTransactionResult
{
CommitDigest = new MemoryStream(h1.Hash),
TransactionId = TestTransactionId
},
ResponseMetadata = new ResponseMetadata
{
RequestId = "testId"
}
};
mockClient.SetupSequence(x => x.SendCommandAsync(It.IsAny <SendCommandRequest>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(sendCommandResponseWithStartSession))
.Returns(Task.FromResult(sendCommandResponseStartTransaction))
.Returns(Task.FromResult(sendCommandResponseExecute))
.Returns(Task.FromResult(sendCommandResponseCommit));
var driver = new QldbDriver(
new SessionPool(() => Session.StartSession("ledgerName", mockClient.Object, NullLogger.Instance),
QldbDriverBuilder.CreateDefaultRetryHandler(NullLogger.Instance), 4, NullLogger.Instance));
var result = await driver.ListTableNames();
Assert.IsNotNull(result);
CollectionAssert.AreEqual(tables, result.ToList());
}
public void Execute_UpdateSameRecordAtSameTime_ThrowsOccException()
{
// Create a driver that does not retry OCC errors
QldbDriver driver = integrationTestBase.CreateDriver(amazonQldbSessionConfig, default, default);