public void Run(
bool interceptors,
bool dynamic,
bool inMemoryDb)
{
using (var queueContainer = new QueueContainer<SqLiteMessageQueueInit>(x => {}))
{
using (var connectionInfo = new IntegrationConnectionInfo(inMemoryDb))
{
var queueName = GenerateQueueName.Create();
try
{
var tests = new JobSchedulerTestsShared();
if (!dynamic)
{
tests.RunEnqueueTestCompiled<SqLiteMessageQueueInit, SqliteJobQueueCreation>(queueName,
connectionInfo.ConnectionString, interceptors,
Helpers.Verify, Helpers.SetError, queueContainer.CreateTimeSync(connectionInfo.ConnectionString));
}
else
{
tests.RunEnqueueTestDynamic<SqLiteMessageQueueInit, SqliteJobQueueCreation>(queueName,
connectionInfo.ConnectionString, interceptors,
Helpers.Verify, Helpers.SetError, queueContainer.CreateTimeSync(connectionInfo.ConnectionString));
}
}
finally
{
using (var queueCreator =
new QueueCreationContainer<SqLiteMessageQueueInit>())
{
using (
var oCreation =
queueCreator.GetQueueCreation<SqLiteMessageQueueCreation>(queueName,
connectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
}
}
public void Run(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)
)
{
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
RunTest(queueName, 100, 10, logProvider, connectionInfo.ConnectionString, linqMethodTypes);
LoggerShared.CheckForErrors(queueName);
new VerifyQueueData(queueName, connectionInfo.ConnectionString, oCreation.Options).Verify(100 * 10, null);
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation<SqLiteMessageQueueCreation>(queueName,
connectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
}
public void Run(
bool interceptors,
int producerCount,
bool inMemoryDb)
{
using (var connectionInfo = new IntegrationConnectionInfo(inMemoryDb))
{
var queueName = GenerateQueueName.Create();
using (var queueContainer = new QueueContainer<SqLiteMessageQueueInit>(x => {
}))
{
try
{
var tests = new JobSchedulerTestsShared();
tests.RunTestMultipleProducers<SqLiteMessageQueueInit, SqliteJobQueueCreation>(queueName,
connectionInfo.ConnectionString, interceptors, producerCount, queueContainer.CreateTimeSync(connectionInfo.ConnectionString));
}
finally
{
using (var queueCreator =
new QueueCreationContainer<SqLiteMessageQueueInit>())
{
using (
var oCreation =
queueCreator.GetQueueCreation<SqLiteMessageQueueCreation>(queueName,
connectionInfo.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.CreateCompiled, runtime);
}
else
{
producer.RunTestDynamic<SqLiteMessageQueueInit>(queueName,
connectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateDynamic, runtime);
}
var consumer = new ConsumerMethodShared();
consumer.RunConsumer<SqLiteMessageQueueInit>(queueName, connectionInfo.ConnectionString,
false,
logProvider,
runtime, messageCount,
workerCount, timeOut,
TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(35), id);
new VerifyQueueRecordCount(queueName, connectionInfo.ConnectionString, oCreation.Options).Verify(0, false, false);
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation<SqLiteMessageQueueCreation>(queueName,
connectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
}
public async void Run(
int messageCount,
bool interceptors,
bool enableDelayedProcessing,
bool enableHeartBeat,
bool enableMessageExpiration,
bool enablePriority,
bool enableStatus,
bool enableStatusTable,
bool additionalColumn,
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 = 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, false, null));
}
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
var producer = new ProducerMethodAsyncShared();
var id = Guid.NewGuid();
await producer.RunTest<SqLiteMessageQueueInit>(queueName,
connectionInfo.ConnectionString, interceptors, messageCount, logProvider,
Helpers.GenerateData,
Helpers.Verify, true, 0, id, linqMethodTypes);
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation<SqLiteMessageQueueCreation>(queueName,
connectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
}
public void Run(int messageCount, int runtime, int timeOut,
int workerCount, bool async, bool inMemoryDb, LinqMethodTypes linqMethodTypes)
{
var queueNameSend = GenerateQueueName.Create();
var queueNameReceive = GenerateQueueName.Create();
var logProviderSend = LoggerShared.Create(queueNameSend, GetType().Name);
var logProviderReceive = LoggerShared.Create(queueNameReceive, GetType().Name);
using (var connectionInfo = new IntegrationConnectionInfo(inMemoryDb))
{
using (var queueCreatorReceive =
new QueueCreationContainer<SqLiteMessageQueueInit>(
serviceRegister => serviceRegister.Register(() => logProviderReceive, LifeStyles.Singleton)))
{
using (var queueCreatorSend =
new QueueCreationContainer<SqLiteMessageQueueInit>(
serviceRegister => serviceRegister.Register(() => logProviderSend, LifeStyles.Singleton)))
{
try
{
using (
var oCreationReceive =
queueCreatorReceive.GetQueueCreation<SqLiteMessageQueueCreation>(queueNameReceive,
connectionInfo.ConnectionString)
)
{
oCreationReceive.Options.EnableDelayedProcessing = true;
oCreationReceive.Options.EnableHeartBeat = true;
oCreationReceive.Options.EnableStatus = true;
oCreationReceive.Options.EnableStatusTable = true;
oCreationReceive.Options.QueueType = QueueTypes.RpcReceive;
var resultReceive = oCreationReceive.CreateQueue();
Assert.True(resultReceive.Success, resultReceive.ErrorMessage);
using (
var oCreation =
queueCreatorSend.GetQueueCreation<SqLiteMessageQueueCreation>(queueNameSend,
connectionInfo.ConnectionString)
)
{
oCreation.Options.EnableDelayedProcessing = true;
oCreation.Options.EnableHeartBeat = true;
oCreation.Options.EnableStatus = true;
oCreation.Options.EnableStatusTable = true;
oCreation.Options.QueueType = QueueTypes.RpcSend;
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
var rpc =
new RpcMethodShared
<SqLiteMessageQueueInit, FakeResponse, SqLiteRpcConnection>();
var id = Guid.NewGuid();
rpc.Run(queueNameReceive, queueNameSend, connectionInfo.ConnectionString,
connectionInfo.ConnectionString, logProviderReceive, logProviderSend,
runtime, messageCount, workerCount, timeOut, async,
new SqLiteRpcConnection(connectionInfo.ConnectionString, queueNameSend,
connectionInfo.ConnectionString, queueNameReceive),
TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(35), id, linqMethodTypes);
new VerifyQueueRecordCount(queueNameSend, connectionInfo.ConnectionString, oCreation.Options).Verify(0, false, false);
new VerifyQueueRecordCount(queueNameReceive, connectionInfo.ConnectionString, oCreationReceive.Options).Verify(0, false,
false);
}
}
}
finally
{
using (
var oCreation =
queueCreatorSend.GetQueueCreation<SqLiteMessageQueueCreation>(queueNameSend,
connectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
using (
var oCreation =
queueCreatorReceive.GetQueueCreation<SqLiteMessageQueueCreation>(queueNameReceive,
connectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
}
}
