private void RunTest(string queueName, int messageCount, int queueCount, ILogProvider logProvider, Guid id, int runTime, LinqMethodTypes linqMethodTypes)
{
var tasks = new List<Task>(queueCount);
for (var i = 0; i < queueCount; i++)
{
var producer = new ProducerMethodShared();
switch (linqMethodTypes)
{
case LinqMethodTypes.Dynamic:
tasks.Add(
new Task(
() =>
producer.RunTestDynamic<PostgreSqlMessageQueueInit>(queueName,
ConnectionInfo.ConnectionString, false, messageCount,
logProvider, Helpers.GenerateData, Helpers.NoVerification, true, false, id,
GenerateMethod.CreateDynamic, runTime)));
break;
case LinqMethodTypes.Compiled:
tasks.Add(
new Task(
() =>
producer.RunTestCompiled<PostgreSqlMessageQueueInit>(queueName,
ConnectionInfo.ConnectionString, false, messageCount,
logProvider, Helpers.GenerateData, Helpers.NoVerification, true, false, id,
GenerateMethod.CreateCompiled, runTime)));
break;
}
}
tasks.AsParallel().ForAll(x => x.Start());
Task.WaitAll(tasks.ToArray());
}
public void Run(int messageCount, int timeOut,
int workerCount, ConnectionInfoTypes type, LinqMethodTypes linqMethodTypes)
{
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
{
//create data
var id = Guid.NewGuid();
var producer = new ProducerMethodShared();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled<RedisQueueInit>(queueName,
connectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateNoOpCompiled, 0);
}
else
{
producer.RunTestDynamic<RedisQueueInit>(queueName,
connectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateNoOpDynamic, 0);
}
//process data
var consumer = new ConsumerMethodPoisonMessageShared();
consumer.RunConsumer<RedisQueueInit>(queueName, connectionString, false,
workerCount,
logProvider, timeOut, messageCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12));
ValidateErrorCounts(queueName, connectionString, messageCount);
using (
var count = new VerifyQueueRecordCount(queueName, connectionString))
{
count.Verify(messageCount, true, 2);
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation<RedisQueueCreation>(queueName,
connectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
public void Run(int messageCount, int runtime,
int timeOut, int workerCount, ConnectionInfoTypes type, LinqMethodTypes linqMethodTypes)
{
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
{
var id = Guid.NewGuid();
var producer = new ProducerMethodShared();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled<RedisQueueInit>(queueName,
connectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateCancelCompiled, runtime);
}
else
{
producer.RunTestDynamic<RedisQueueInit>(queueName,
connectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateCancelDynamic, runtime);
}
var consumer = new ConsumerMethodHeartBeatShared();
consumer.RunConsumer<RedisQueueInit>(queueName, connectionString, false,
logProvider,
runtime, messageCount,
workerCount, timeOut, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), id);
using (var count = new VerifyQueueRecordCount(queueName, connectionString))
{
count.Verify(0, false, -1);
}
GenerateMethod.ClearCancel(id);
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation<RedisQueueCreation>(queueName,
connectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
private void RunTest(string queueName, int messageCount, int queueCount, ILogProvider logProvider, string connectionString, LinqMethodTypes linqMethodTypes, ICreationScope scope, bool enableChaos)
{
var tasks = new List <Task>(queueCount);
for (var i = 0; i < queueCount; i++)
{
var id = Guid.NewGuid();
var producer = new ProducerMethodShared();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
tasks.Add(new Task(() => producer.RunTestCompiled <SqLiteMessageQueueInit>(queueName, connectionString, false, messageCount,
logProvider, Helpers.GenerateData, Helpers.NoVerification, true, false, id, GenerateMethod.CreateCompiled, 0, scope, enableChaos)));
}
else
{
tasks.Add(new Task(() => producer.RunTestDynamic <SqLiteMessageQueueInit>(queueName, connectionString, false, messageCount,
logProvider, Helpers.GenerateData, Helpers.NoVerification, true, false, id, GenerateMethod.CreateDynamic, 0, scope, enableChaos)));
}
}
tasks.AsParallel().ForAll(x => x.Start());
Task.WaitAll(tasks.ToArray());
}
public void Run(
int messageCount,
bool interceptors,
bool enableDelayedProcessing,
bool enableHeartBeat,
bool enableMessageExpiration,
bool enablePriority,
bool enableStatus,
bool enableStatusTable,
bool additionalColumn,
bool inMemoryDb,
LinqMethodTypes linqMethodTypes,
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 = enableDelayedProcessing;
oCreation.Options.EnableHeartBeat = enableHeartBeat;
oCreation.Options.EnableMessageExpiration = enableMessageExpiration;
oCreation.Options.EnablePriority = enablePriority;
oCreation.Options.EnableStatus = enableStatus;
oCreation.Options.EnableStatusTable = enableStatusTable;
if (additionalColumn)
{
oCreation.Options.AdditionalColumns.Add(new Column("OrderID", ColumnTypes.Integer, true, null));
}
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
var id = Guid.NewGuid();
var producer = new ProducerMethodShared();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <SqLiteMessageQueueInit>(queueName,
connectionInfo.ConnectionString, interceptors, messageCount, logProvider,
Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateCompiled, 0, oCreation.Scope, enableChaos);
}
else
{
producer.RunTestDynamic <SqLiteMessageQueueInit>(queueName,
connectionInfo.ConnectionString, interceptors, messageCount, logProvider,
Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateDynamic, 0, oCreation.Scope, enableChaos);
}
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation <SqLiteMessageQueueCreation>(queueName,
connectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
}
public void Run(int messageCount, int runtime, int timeOut, int workerCount, bool useTransactions, LinqMethodTypes linqMethodTypes)
{
var queueName = GenerateQueueName.Create();
var logProvider = LoggerShared.Create(queueName, GetType().Name);
using (
var queueCreator =
new QueueCreationContainer <PostgreSqlMessageQueueInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
try
{
using (
var oCreation =
queueCreator.GetQueueCreation <PostgreSqlMessageQueueCreation>(queueName,
ConnectionInfo.ConnectionString)
)
{
oCreation.Options.EnableDelayedProcessing = true;
oCreation.Options.EnableHeartBeat = !useTransactions;
oCreation.Options.EnableHoldTransactionUntilMessageCommitted = useTransactions;
oCreation.Options.EnableStatus = !useTransactions;
oCreation.Options.EnableStatusTable = true;
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
var id = Guid.NewGuid();
//create data
var producer = new ProducerMethodShared();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <PostgreSqlMessageQueueInit>(queueName,
ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateRollBackCompiled, runtime, oCreation.Scope);
}
#if NETFULL
else
{
producer.RunTestDynamic <PostgreSqlMessageQueueInit>(queueName,
ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateRollBackDynamic, runtime, oCreation.Scope);
}
#endif
//process data
var consumer = new ConsumerMethodRollBackShared();
consumer.RunConsumer <PostgreSqlMessageQueueInit>(queueName, ConnectionInfo.ConnectionString,
false,
workerCount, logProvider, timeOut, runtime, messageCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), "second(*%3)", id);
new VerifyQueueRecordCount(queueName, oCreation.Options).Verify(0, false, false);
GenerateMethod.ClearRollback(id);
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation <PostgreSqlMessageQueueCreation>(queueName,
ConnectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
public void Run(int messageCount, int timeOut, int workerCount,
int readerCount, int queueSize, bool inMemoryDb, LinqMethodTypes linqMethodTypes)
{
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;
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
//create data
var producer = new ProducerMethodShared();
var id = Guid.NewGuid();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <SqLiteMessageQueueInit>(queueName,
connectionInfo.ConnectionString, false, messageCount, logProvider,
Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateNoOpCompiled, 0, oCreation.Scope);
}
else
{
producer.RunTestDynamic <SqLiteMessageQueueInit>(queueName,
connectionInfo.ConnectionString, false, messageCount, logProvider,
Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateNoOpDynamic, 0, oCreation.Scope);
}
//process data
var consumer = new ConsumerMethodAsyncPoisonMessageShared();
consumer.RunConsumer <SqLiteMessageQueueInit>(queueName, connectionInfo.ConnectionString,
false,
workerCount, logProvider,
timeOut, readerCount, queueSize, messageCount, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(35), "second(*%10)");
ValidateErrorCounts(queueName, connectionInfo.ConnectionString, messageCount);
new VerifyQueueRecordCount(queueName, connectionInfo.ConnectionString, oCreation.Options).Verify(messageCount, true, true);
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation <SqLiteMessageQueueCreation>(queueName,
connectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
}
private void RunTest(string queueName, int messageCount, int queueCount, ILogProvider logProvider, string connectionString, LinqMethodTypes linqMethodTypes)
{
var tasks = new List<Task>(queueCount);
for (var i = 0; i < queueCount; i++)
{
var id = Guid.NewGuid();
var producer = new ProducerMethodShared();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
tasks.Add(new Task(() => producer.RunTestCompiled<SqLiteMessageQueueInit>(queueName, connectionString, false, messageCount,
logProvider, Helpers.GenerateData, Helpers.NoVerification, true, false, id, GenerateMethod.CreateCompiled, 0)));
}
else
{
tasks.Add(new Task(() => producer.RunTestDynamic<SqLiteMessageQueueInit>(queueName, connectionString, false, messageCount,
logProvider, Helpers.GenerateData, Helpers.NoVerification, true, false, id, GenerateMethod.CreateDynamic, 0)));
}
}
tasks.AsParallel().ForAll(x => x.Start());
Task.WaitAll(tasks.ToArray());
}
public void Run(int messageCount, int timeOut, int workerCount,
int readerCount, int queueSize, bool inMemoryDb, LinqMethodTypes linqMethodTypes)
{
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;
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
//create data
var producer = new ProducerMethodShared();
var id = Guid.NewGuid();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled<SqLiteMessageQueueInit>(queueName,
connectionInfo.ConnectionString, false, messageCount, logProvider,
Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateErrorCompiled, 0);
}
else
{
producer.RunTestDynamic<SqLiteMessageQueueInit>(queueName,
connectionInfo.ConnectionString, false, messageCount, logProvider,
Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateErrorDynamic, 0);
}
//process data
var consumer = new ConsumerMethodAsyncErrorShared();
consumer.RunConsumer<SqLiteMessageQueueInit>(queueName,connectionInfo.ConnectionString,
false,
logProvider,
messageCount, workerCount, timeOut, queueSize, readerCount, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(35), id);
ValidateErrorCounts(queueName, connectionInfo.ConnectionString, messageCount);
new VerifyQueueRecordCount(queueName, connectionInfo.ConnectionString, oCreation.Options).Verify(messageCount, true, false);
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation<SqLiteMessageQueueCreation>(queueName,
connectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
}
public void Run(int messageCount, int runtime,
int timeOut, int workerCount, LinqMethodTypes linqMethodTypes)
{
using (var connectionInfo = new IntegrationConnectionInfo())
{
var queueName = GenerateQueueName.Create();
var logProvider = LoggerShared.Create(queueName, GetType().Name);
using (
var queueCreator =
new QueueCreationContainer <MemoryMessageQueueInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
try
{
using (
var oCreation =
queueCreator.GetQueueCreation <MessageQueueCreation>(queueName,
connectionInfo.ConnectionString)
)
{
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
var producer = new ProducerMethodShared();
var id = Guid.NewGuid();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <MemoryMessageQueueInit>(queueName,
connectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateCompiled, runtime, oCreation.Scope);
}
#if NETFULL
else
{
producer.RunTestDynamic <MemoryMessageQueueInit>(queueName,
connectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateDynamic, runtime, oCreation.Scope);
}
#endif
var consumer = new ConsumerMethodShared();
consumer.RunConsumer <MemoryMessageQueueInit>(queueName, connectionInfo.ConnectionString,
false,
logProvider,
runtime, messageCount,
workerCount, timeOut,
TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(35), id, "second(*%10)");
new VerifyQueueRecordCount().Verify(oCreation.Scope, 0, true);
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation <MessageQueueCreation>(queueName,
connectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
}
public void Run(
int messageCount,
bool interceptors,
bool batchSending,
bool enableDelay,
bool enableExpiration,
ConnectionInfoTypes type,
LinqMethodTypes linqMethodTypes)
{
var queueName = GenerateQueueName.Create();
var logProvider = LoggerShared.Create(queueName, GetType().Name);
var producer = new ProducerMethodShared();
var connectionString = new ConnectionInfo(type).ConnectionString;
using (
var queueCreator =
new QueueCreationContainer<RedisQueueInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
try
{
var id = Guid.NewGuid();
if (enableExpiration && enableDelay)
{
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled<RedisQueueInit>(queueName,
connectionString, interceptors, messageCount, logProvider,
Helpers.GenerateDelayExpiredData,
Helpers.Verify, batchSending, id, GenerateMethod.CreateCompiled, 0);
}
else
{
producer.RunTestDynamic<RedisQueueInit>(queueName,
connectionString, interceptors, messageCount, logProvider,
Helpers.GenerateDelayExpiredData,
Helpers.Verify, batchSending, id, GenerateMethod.CreateDynamic, 0);
}
}
else if (enableDelay)
{
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled<RedisQueueInit>(queueName,
connectionString, interceptors, messageCount, logProvider, Helpers.GenerateDelayData,
Helpers.Verify, batchSending, id, GenerateMethod.CreateCompiled, 0);
}
else
{
producer.RunTestDynamic<RedisQueueInit>(queueName,
connectionString, interceptors, messageCount, logProvider, Helpers.GenerateDelayData,
Helpers.Verify, batchSending, id, GenerateMethod.CreateDynamic, 0);
}
}
else if (enableExpiration)
{
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled<RedisQueueInit>(queueName,
connectionString, interceptors, messageCount, logProvider, Helpers.GenerateExpiredData,
Helpers.Verify, batchSending, id, GenerateMethod.CreateCompiled, 0);
}
else
{
producer.RunTestDynamic<RedisQueueInit>(queueName,
connectionString, interceptors, messageCount, logProvider, Helpers.GenerateExpiredData,
Helpers.Verify, batchSending, id, GenerateMethod.CreateDynamic, 0);
}
}
else
{
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled<RedisQueueInit>(queueName,
connectionString, interceptors, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, batchSending, id, GenerateMethod.CreateCompiled, 0);
}
else
{
producer.RunTestDynamic<RedisQueueInit>(queueName,
connectionString, interceptors, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, batchSending, id, GenerateMethod.CreateDynamic, 0);
}
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation<RedisQueueCreation>(queueName,
connectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
public void Run(int messageCount, int runtime,
int timeOut, int workerCount, bool inMemoryDb, LinqMethodTypes linqMethodTypes)
{
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;
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
var producer = new ProducerMethodShared();
var id = Guid.NewGuid();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <SqLiteMessageQueueInit>(queueName,
connectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateCancelCompiled, runtime, oCreation.Scope);
}
var consumer = new ConsumerMethodCancelWorkShared <SqLiteMessageQueueInit>();
consumer.RunConsumer(queueName, connectionInfo.ConnectionString, false, logProvider,
runtime, messageCount,
workerCount, timeOut,
serviceRegister => serviceRegister.Register <IMessageMethodHandling>(() => new MethodMessageProcessingCancel(id), LifeStyles.Singleton),
TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(35), "second(*%10)", id);
new VerifyQueueRecordCount(queueName, connectionInfo.ConnectionString, oCreation.Options).Verify(0, false, false);
GenerateMethod.ClearCancel(id);
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation <SqLiteMessageQueueCreation>(queueName,
connectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
}
public void Run(
int messageCount,
bool interceptors,
bool enableDelayedProcessing,
bool enableHeartBeat,
bool enableHoldTransactionUntilMessageCommited,
bool enableMessageExpiration,
bool enablePriority,
bool enableStatus,
bool enableStatusTable,
bool additionalColumn,
LinqMethodTypes linqMethodTypes)
{
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 = enableDelayedProcessing;
oCreation.Options.EnableHeartBeat = enableHeartBeat;
oCreation.Options.EnableMessageExpiration = enableMessageExpiration;
oCreation.Options.EnableHoldTransactionUntilMessageCommited = enableHoldTransactionUntilMessageCommited;
oCreation.Options.EnablePriority = enablePriority;
oCreation.Options.EnableStatus = enableStatus;
oCreation.Options.EnableStatusTable = enableStatusTable;
if (additionalColumn)
{
oCreation.Options.AdditionalColumns.Add(new Column("OrderID", ColumnTypes.Int, false, null));
}
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
var producer = new ProducerMethodShared();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled<SqlServerMessageQueueInit>(queueName,
ConnectionInfo.ConnectionString, interceptors, messageCount, logProvider,
Helpers.GenerateData,
Helpers.Verify, true, Guid.NewGuid(), GenerateMethod.CreateCompiled, 0);
}
else
{
producer.RunTestDynamic<SqlServerMessageQueueInit>(queueName,
ConnectionInfo.ConnectionString, interceptors, messageCount, logProvider,
Helpers.GenerateData,
Helpers.Verify, true, Guid.NewGuid(), GenerateMethod.CreateDynamic, 0);
}
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation<SqlServerMessageQueueCreation>(queueName,
ConnectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
public void Run(
int messageCount,
bool interceptors,
bool batchSending,
bool enableDelay,
bool enableExpiration,
ConnectionInfoTypes type,
LinqMethodTypes linqMethodTypes)
{
var queueName = GenerateQueueName.Create();
var logProvider = LoggerShared.Create(queueName, GetType().Name);
var producer = new ProducerMethodShared();
var connectionString = new ConnectionInfo(type).ConnectionString;
using (
var queueCreator =
new QueueCreationContainer <RedisQueueInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
try
{
var id = Guid.NewGuid();
if (enableExpiration && enableDelay)
{
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <RedisQueueInit>(queueName,
connectionString, interceptors, messageCount, logProvider,
Helpers.GenerateDelayExpiredData,
Helpers.Verify, batchSending, id, GenerateMethod.CreateCompiled, 0, null);
}
#if NETFULL
else
{
producer.RunTestDynamic <RedisQueueInit>(queueName,
connectionString, interceptors, messageCount, logProvider,
Helpers.GenerateDelayExpiredData,
Helpers.Verify, batchSending, id, GenerateMethod.CreateDynamic, 0, null);
}
#endif
}
else if (enableDelay)
{
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <RedisQueueInit>(queueName,
connectionString, interceptors, messageCount, logProvider, Helpers.GenerateDelayData,
Helpers.Verify, batchSending, id, GenerateMethod.CreateCompiled, 0, null);
}
#if NETFULL
else
{
producer.RunTestDynamic <RedisQueueInit>(queueName,
connectionString, interceptors, messageCount, logProvider, Helpers.GenerateDelayData,
Helpers.Verify, batchSending, id, GenerateMethod.CreateDynamic, 0, null);
}
#endif
}
else if (enableExpiration)
{
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <RedisQueueInit>(queueName,
connectionString, interceptors, messageCount, logProvider, Helpers.GenerateExpiredData,
Helpers.Verify, batchSending, id, GenerateMethod.CreateCompiled, 0, null);
}
#if NETFULL
else
{
producer.RunTestDynamic <RedisQueueInit>(queueName,
connectionString, interceptors, messageCount, logProvider, Helpers.GenerateExpiredData,
Helpers.Verify, batchSending, id, GenerateMethod.CreateDynamic, 0, null);
}
#endif
}
else
{
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <RedisQueueInit>(queueName,
connectionString, interceptors, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, batchSending, id, GenerateMethod.CreateCompiled, 0, null);
}
#if NETFULL
else
{
producer.RunTestDynamic <RedisQueueInit>(queueName,
connectionString, interceptors, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, batchSending, id, GenerateMethod.CreateDynamic, 0, null);
}
#endif
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation <RedisQueueCreation>(queueName,
connectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
public void Run(int messageCount, int timeOut, int workerCount,
int readerCount, int queueSize, bool useTransactions, LinqMethodTypes linqMethodTypes, bool enableChaos)
{
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.EnableHoldTransactionUntilMessageCommitted = useTransactions;
oCreation.Options.EnableStatus = !useTransactions;
oCreation.Options.EnableStatusTable = true;
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
var id = Guid.NewGuid();
//create data
var producer = new ProducerMethodShared();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <SqlServerMessageQueueInit>(queueName,
ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateErrorCompiled, 0, oCreation.Scope, false);
}
#if NETFULL
else
{
producer.RunTestDynamic <SqlServerMessageQueueInit>(queueName,
ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateErrorDynamic, 0, oCreation.Scope, false);
}
#endif
//process data
var consumer = new ConsumerMethodAsyncErrorShared();
consumer.RunConsumer <SqlServerMessageQueueInit>(queueName, ConnectionInfo.ConnectionString,
false,
logProvider,
messageCount, workerCount, timeOut, queueSize, readerCount,
TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), id, "second(*%3)", enableChaos);
ValidateErrorCounts(queueName, messageCount);
new VerifyQueueRecordCount(queueName, oCreation.Options).Verify(messageCount, true, false);
//don't purge
consumer.PurgeErrorMessages <SqlServerMessageQueueInit>(queueName, ConnectionInfo.ConnectionString,
false, logProvider, false);
ValidateErrorCounts(queueName, messageCount);
//purge error messages and verify that count is 0
consumer.PurgeErrorMessages <SqlServerMessageQueueInit>(queueName, ConnectionInfo.ConnectionString,
false, logProvider, true);
ValidateErrorCounts(queueName, 0);
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation <SqlServerMessageQueueCreation>(queueName,
ConnectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
public void Run <TTransportInit, TTransportCreate>(
QueueConnection queueConnection,
int messageCount, int timeOut, int workerCount, LinqMethodTypes linqMethodTypes,
bool enableChaos,
Action <TTransportCreate> setOptions,
Func <QueueProducerConfiguration, AdditionalMessageData> generateData,
Action <QueueConnection, QueueProducerConfiguration, long, ICreationScope> verify,
Action <QueueConnection, IBaseTransportOptions, ICreationScope, int, bool, bool> verifyQueueCount,
Action <QueueConnection, int, ICreationScope> validateErrorCounts)
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;
//create data
var producer = new ProducerMethodShared();
var id = Guid.NewGuid();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <TTransportInit>(queueConnection, false, messageCount,
logProvider, generateData,
verify, false, id, GenerateMethod.CreateNoOpCompiled, 0, oCreation.Scope,
false);
}
else
{
producer.RunTestDynamic <TTransportInit>(queueConnection, false, messageCount,
logProvider, generateData,
verify, false, id, GenerateMethod.CreateNoOpDynamic, 0, oCreation.Scope, false);
}
//process data
var consumer = new ConsumerMethodPoisonMessageShared();
consumer.RunConsumer <TTransportInit>(queueConnection,
false,
workerCount,
logProvider, timeOut, messageCount, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(35),
"second(*%10)", enableChaos, scope);
validateErrorCounts(queueConnection, messageCount, scope);
verifyQueueCount(queueConnection, oCreation.BaseTransportOptions, scope, messageCount, true, true);
}
finally
{
oCreation.RemoveQueue();
oCreation.Dispose();
scope?.Dispose();
}
}
}
public void Run(int messageCount, int runtime, int timeOut, int workerCount, bool useTransactions, LinqMethodTypes linqMethodTypes)
{
var queueName = GenerateQueueName.Create();
var logProvider = LoggerShared.Create(queueName, GetType().Name);
using (
var queueCreator =
new QueueCreationContainer<PostgreSqlMessageQueueInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
try
{
using (
var oCreation =
queueCreator.GetQueueCreation<PostgreSqlMessageQueueCreation>(queueName,
ConnectionInfo.ConnectionString)
)
{
oCreation.Options.EnableMessageExpiration = true;
oCreation.Options.EnableDelayedProcessing = true;
oCreation.Options.EnableHeartBeat = !useTransactions;
oCreation.Options.EnableHoldTransactionUntilMessageCommited = useTransactions;
oCreation.Options.EnableStatus = !useTransactions;
oCreation.Options.EnableStatusTable = true;
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
var id = Guid.NewGuid();
var producer = new ProducerMethodShared();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled<PostgreSqlMessageQueueInit>(queueName,
ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateCompiled, runtime);
}
else
{
producer.RunTestDynamic<PostgreSqlMessageQueueInit>(queueName,
ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateDynamic, runtime);
}
var consumer = new ConsumerMethodExpiredMessageShared();
consumer.RunConsumer<PostgreSqlMessageQueueInit>(queueName, ConnectionInfo.ConnectionString,
false,
logProvider,
runtime, messageCount,
workerCount, timeOut, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), id);
new VerifyQueueRecordCount(queueName, oCreation.Options).Verify(0, false, false);
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation<PostgreSqlMessageQueueCreation>(queueName,
ConnectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
public void Run(int messageCount, int timeOut, int workerCount, int readerCount, int queueSize, ConnectionInfoTypes type, LinqMethodTypes linqMethodTypes)
{
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
{
//create data
var id = Guid.NewGuid();
var producer = new ProducerMethodShared();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <RedisQueueInit>(queueName,
connectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateErrorCompiled, 0, null, false);
}
#if NETFULL
else
{
producer.RunTestDynamic <RedisQueueInit>(queueName,
connectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateErrorDynamic, 0, null, false);
}
#endif
//process data
var consumer = new ConsumerMethodAsyncErrorShared();
consumer.RunConsumer <RedisQueueInit>(queueName, connectionString, false,
logProvider,
messageCount, workerCount, timeOut, queueSize, readerCount, TimeSpan.FromSeconds(10),
TimeSpan.FromSeconds(12), id, "second(*%3)", false);
ValidateErrorCounts(queueName, messageCount, connectionString);
using (
var count = new VerifyQueueRecordCount(queueName, connectionString))
{
count.Verify(messageCount, false, 2);
}
consumer.PurgeErrorMessages <RedisQueueInit>(queueName, connectionString,
false, logProvider, false);
ValidateErrorCounts(queueName, messageCount, connectionString);
//purge error messages and verify that count is 0
consumer.PurgeErrorMessages <RedisQueueInit>(queueName, connectionString,
false, logProvider, true);
ValidateErrorCounts(queueName, 0, connectionString);
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation <RedisQueueCreation>(queueName,
connectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
