public void Run(int messageCount, int runtime, int timeOut, int readerCount,
bool inMemoryDb, int routeCount, bool enableChaos)
{
using (var connectionInfo = new IntegrationConnectionInfo(inMemoryDb))
{
var queueName = GenerateQueueName.Create();
var logProvider = LoggerShared.Create(queueName, GetType().Name);
using (var queueCreator =
new QueueCreationContainer <SqLiteMessageQueueInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
try
{
using (
var oCreation =
queueCreator.GetQueueCreation <SqLiteMessageQueueCreation>(queueName,
connectionInfo.ConnectionString)
)
{
oCreation.Options.EnableDelayedProcessing = true;
oCreation.Options.EnableHeartBeat = true;
oCreation.Options.EnableStatus = true;
oCreation.Options.EnableStatusTable = true;
oCreation.Options.EnableRoute = true;
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
var routeTest = new RouteMultiTestsShared();
routeTest.RunTest <SqLiteMessageQueueInit, FakeMessageA>(queueName,
connectionInfo.ConnectionString,
true, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false,
GenerateRoutes(routeCount, 1), GenerateRoutes(routeCount, routeCount + 1), runtime,
timeOut, readerCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), oCreation.Scope, "second(*%3)", enableChaos);
new VerifyQueueRecordCount(queueName, connectionInfo.ConnectionString, oCreation.Options).Verify(0, false, false);
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation <SqLiteMessageQueueCreation>(queueName,
connectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
}
public void Run(int messageCount, int runtime, int timeOut, int readerCount,
int routeCount, bool enableChaos, IntegrationConnectionInfo.ConnectionTypes connectionType)
{
using (var connectionInfo = new IntegrationConnectionInfo(connectionType))
{
var queueName = GenerateQueueName.Create();
var consumer = new DotNetWorkQueue.IntegrationTests.Shared.Route.Implementation.RouteMultiTests();
consumer.Run <LiteDbMessageQueueInit, LiteDbMessageQueueCreation>(new QueueConnection(queueName,
connectionInfo.ConnectionString),
messageCount, runtime, timeOut, readerCount, routeCount, enableChaos, x => { Helpers.SetOptions(x, false, false, true, true); },
Helpers.GenerateData, Helpers.Verify, Helpers.VerifyQueueCount);
}
using (var connectionInfo = new IntegrationConnectionInfo(connectionType))
{
var queueName = GenerateQueueName.Create();
var logProvider = LoggerShared.Create(queueName, GetType().Name);
using (var queueCreator =
new QueueCreationContainer <LiteDbMessageQueueInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
var queueConnection = new DotNetWorkQueue.Configuration.QueueConnection(queueName, connectionInfo.ConnectionString);
ICreationScope scope = null;
var oCreation = queueCreator.GetQueueCreation <LiteDbMessageQueueCreation>(queueConnection);
try
{
oCreation.Options.EnableStatusTable = true;
oCreation.Options.EnableRoute = true;
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
scope = oCreation.Scope;
var routeTest = new RouteMultiTestsShared();
routeTest.RunTest <LiteDbMessageQueueInit, FakeMessageA>(queueConnection,
true, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false,
GenerateRoutes(routeCount, 1), GenerateRoutes(routeCount, routeCount + 1), runtime,
timeOut, readerCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), oCreation.Scope,
"second(*%3)", enableChaos);
new VerifyQueueRecordCount(queueName, connectionInfo.ConnectionString, oCreation.Options, scope)
.Verify(0, false, false);
}
finally
{
oCreation?.RemoveQueue();
oCreation?.Dispose();
scope?.Dispose();
}
}
}
}
public void Run(int messageCount, int runtime, int timeOut, int readerCount,
bool useTransactions, int routeCount)
{
var queueName = GenerateQueueName.Create();
var logProvider = LoggerShared.Create(queueName, GetType().Name);
using (var queueCreator =
new QueueCreationContainer<SqlServerMessageQueueInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
try
{
using (
var oCreation =
queueCreator.GetQueueCreation<SqlServerMessageQueueCreation>(queueName,
ConnectionInfo.ConnectionString)
)
{
oCreation.Options.EnableDelayedProcessing = true;
oCreation.Options.EnableHeartBeat = !useTransactions;
oCreation.Options.EnableHoldTransactionUntilMessageCommited = useTransactions;
oCreation.Options.EnableStatus = !useTransactions;
oCreation.Options.EnableStatusTable = true;
oCreation.Options.EnableRoute = true;
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
var routeTest = new RouteMultiTestsShared();
routeTest.RunTest<SqlServerMessageQueueInit, FakeMessageA>(queueName, ConnectionInfo.ConnectionString,
true, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false,
GenerateRoutes(routeCount, 1), GenerateRoutes(routeCount, routeCount + 1), runtime, timeOut, readerCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12));
new VerifyQueueRecordCount(queueName, oCreation.Options).Verify(0, false, false);
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation<SqlServerMessageQueueCreation>(queueName,
ConnectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
public void Run(int messageCount, int runtime, int timeOut, int readerCount,
int routeCount, ConnectionInfoTypes type)
{
var queueName = GenerateQueueName.Create();
var logProvider = LoggerShared.Create(queueName, GetType().Name);
var connectionString = new ConnectionInfo(type).ConnectionString;
using (var queueCreator =
new QueueCreationContainer <RedisQueueInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
try
{
using (
var oCreation =
queueCreator.GetQueueCreation <RedisQueueCreation>(queueName,
connectionString)
)
{
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
var routeTest = new RouteMultiTestsShared();
routeTest.RunTest <RedisQueueInit, FakeMessageA>(queueName, connectionString,
true, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false,
GenerateRoutes(routeCount, 1), GenerateRoutes(routeCount, routeCount + 1), runtime, timeOut, readerCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), oCreation.Scope, "second(*%3)");
using (var count = new VerifyQueueRecordCount(queueName, connectionString))
{
count.Verify(0, false, -1);
}
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation <RedisQueueCreation>(queueName,
connectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
public void Run(int messageCount, int runtime, int timeOut, int readerCount,
int routeCount, ConnectionInfoTypes type)
{
var queueName = GenerateQueueName.Create();
var logProvider = LoggerShared.Create(queueName, GetType().Name);
var connectionString = new ConnectionInfo(type).ConnectionString;
using (var queueCreator =
new QueueCreationContainer<RedisQueueInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
try
{
using (
var oCreation =
queueCreator.GetQueueCreation<RedisQueueCreation>(queueName,
connectionString)
)
{
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
var routeTest = new RouteMultiTestsShared();
routeTest.RunTest<RedisQueueInit, FakeMessageA>(queueName, connectionString,
true, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false,
GenerateRoutes(routeCount, 1), GenerateRoutes(routeCount, routeCount + 1), runtime, timeOut, readerCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12));
using (var count = new VerifyQueueRecordCount(queueName, connectionString))
{
count.Verify(0, false, -1);
}
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation<RedisQueueCreation>(queueName,
connectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
public void Run <TTransportInit, TTransportCreate>(
QueueConnection queueConnection,
int messageCount, int runtime, int timeOut, int readerCount,
int routeCount, bool enableChaos,
Action <TTransportCreate> setOptions,
Func <QueueProducerConfiguration, AdditionalMessageData> generateData,
Action <QueueConnection, QueueProducerConfiguration, long, string, ICreationScope> verify,
Action <QueueConnection, IBaseTransportOptions, ICreationScope, int, bool, bool> verifyQueueCount)
where TTransportInit : ITransportInit, new()
where TTransportCreate : class, IQueueCreation
{
var logProvider = LoggerShared.Create(queueConnection.Queue, GetType().Name);
using (var queueCreator =
new QueueCreationContainer <TTransportInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
ICreationScope scope = null;
var oCreation = queueCreator.GetQueueCreation <TTransportCreate>(queueConnection);
try
{
setOptions(oCreation);
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
scope = oCreation.Scope;
var routeTest = new RouteMultiTestsShared();
routeTest.RunTest <TTransportInit, FakeMessageA>(queueConnection,
true, messageCount, logProvider, generateData, verify, false,
GenerateRoutes(routeCount, 1), GenerateRoutes(routeCount, routeCount + 1), runtime,
timeOut, readerCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), oCreation.Scope,
"second(*%3)", enableChaos);
verifyQueueCount(queueConnection, oCreation.BaseTransportOptions, scope, 0, false, false);
}
finally
{
oCreation?.RemoveQueue();
oCreation?.Dispose();
scope?.Dispose();
}
}
}
