public void Run(int messageCount, bool enableChaos, IntegrationConnectionInfo.ConnectionTypes connectionType)
{
using (var connectionInfo = new IntegrationConnectionInfo(connectionType))
{
var queueName = GenerateQueueName.Create();
var producer = new DotNetWorkQueue.IntegrationTests.Shared.Producer.Implementation.MultiProducer();
producer.Run <LiteDbMessageQueueInit, FakeMessage, LiteDbMessageQueueCreation>(new QueueConnection(queueName,
connectionInfo.ConnectionString),
messageCount, enableChaos, 10, x => { }, Helpers.GenerateData, Helpers.Verify, VerifyQueueData);
}
}
public async Task Run(int messageCount, int runtime, int timeOut, int workerCount,
int readerCount, int queueSize, bool enableChaos, IntegrationConnectionInfo.ConnectionTypes connectionType)
{
using (var connectionInfo = new IntegrationConnectionInfo(connectionType))
{
var consumer =
new DotNetWorkQueue.IntegrationTests.Shared.ConsumerAsync.Implementation.MultiConsumerAsync();
await consumer.Run <LiteDbMessageQueueInit, LiteDbMessageQueueCreation>(GetConnections(connectionInfo.ConnectionString),
messageCount, runtime, timeOut, workerCount, readerCount, queueSize, enableChaos, x => Helpers.SetOptions(x, false, false, true),
Helpers.GenerateData, Helpers.Verify, Helpers.VerifyQueueCount).ConfigureAwait(false);
}
}
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,
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.RouteTests();
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);
}
}
public void Run(int messageCount, int timeOut, int workerCount,
int readerCount, int queueSize, bool enableChaos, IntegrationConnectionInfo.ConnectionTypes connectionType)
{
using (var connectionInfo = new IntegrationConnectionInfo(connectionType))
{
var queueName = GenerateQueueName.Create();
var consumer =
new DotNetWorkQueue.IntegrationTests.Shared.ConsumerAsync.Implementation.ConsumerAsyncErrorTable();
consumer.Run <LiteDbMessageQueueInit, FakeMessage, LiteDbMessageQueueCreation>(new QueueConnection(queueName,
connectionInfo.ConnectionString),
messageCount, timeOut, workerCount, readerCount, queueSize, enableChaos, x => Helpers.SetOptions(x, true, false, true),
Helpers.GenerateData, Helpers.Verify, Helpers.VerifyQueueCount, ValidateErrorCounts);
}
}
public void Run(int messageCount, LinqMethodTypes linqMethodTypes, bool enableChaos,
IntegrationConnectionInfo.ConnectionTypes connectionType)
{
using (var connectionInfo = new IntegrationConnectionInfo(connectionType))
{
var queueName = GenerateQueueName.Create();
var consumer =
new DotNetWorkQueue.IntegrationTests.Shared.ProducerMethod.Implementation.MultiMethodProducer();
consumer.Run <LiteDbMessageQueueInit, LiteDbMessageQueueCreation>(new QueueConnection(queueName,
connectionInfo.ConnectionString),
messageCount, 10, linqMethodTypes, enableChaos,
Helpers.GenerateData, VerifyQueueCount);
}
}
public void Run(
int messageCount,
bool interceptors,
bool enableStatusTable,
bool enableChaos,
IntegrationConnectionInfo.ConnectionTypes connectionType)
{
using (var connectionInfo = new IntegrationConnectionInfo(connectionType))
{
var queueName = GenerateQueueName.Create();
var producer = new DotNetWorkQueue.IntegrationTests.Shared.Producer.Implementation.SimpleProducer();
producer.Run <LiteDbMessageQueueInit, FakeMessage, LiteDbMessageQueueCreation>(new QueueConnection(queueName,
connectionInfo.ConnectionString),
messageCount, interceptors, enableChaos, false, x => x.Options.EnableStatusTable = enableStatusTable,
Helpers.GenerateData, Helpers.Verify);
}
}
public void Run(
int messageCount,
bool interceptors,
bool enableDelayedProcessing,
bool enableMessageExpiration,
bool enableStatusTable,
LinqMethodTypes linqMethodTypes,
bool enableChaos,
IntegrationConnectionInfo.ConnectionTypes connectionType)
{
using (var connectionInfo = new IntegrationConnectionInfo(connectionType))
{
var queueName = GenerateQueueName.Create();
var consumer =
new DotNetWorkQueue.IntegrationTests.Shared.ProducerMethod.Implementation.SimpleMethodProducer();
consumer.Run <LiteDbMessageQueueInit, LiteDbMessageQueueCreation>(new QueueConnection(queueName,
connectionInfo.ConnectionString),
messageCount, linqMethodTypes, interceptors, enableChaos, true, x => Helpers.SetOptions(x, enableDelayedProcessing, enableMessageExpiration, enableStatusTable),
Helpers.GenerateData, Helpers.Verify);
}
}
public void Run(int messageCount, int runtime,
int timeOut, int workerCount, LinqMethodTypes linqMethodTypes, bool enableChaos, IntegrationConnectionInfo.ConnectionTypes connectionType)
{
using (var connectionInfo = new IntegrationConnectionInfo(connectionType))
{
var queueName = GenerateQueueName.Create();
var consumer =
new DotNetWorkQueue.IntegrationTests.Shared.ConsumerMethod.Implementation.
ConsumerMethodHeartbeat();
consumer.Run <LiteDbMessageQueueInit, LiteDbMessageQueueCreation>(new QueueConnection(queueName,
connectionInfo.ConnectionString),
messageCount, runtime, timeOut, workerCount, linqMethodTypes, enableChaos, x => Helpers.SetOptions(x, true, false, true),
Helpers.GenerateData, Helpers.Verify, Helpers.VerifyQueueCount);
}
}
