Esempio n. 1
0
        public async Task Run(int messageCount, int runtime, int timeOut, int workerCount, int readerCount, int queueSize, ConnectionInfoTypes type)
        {
            var queueName        = GenerateQueueName.Create();
            var connectionString = new ConnectionInfo(type).ConnectionString;
            var consumer         =
                new DotNetWorkQueue.IntegrationTests.Shared.ConsumerAsync.Implementation.MultiConsumerAsync();

            await consumer.Run <RedisQueueInit, RedisQueueCreation>(GetConnections(connectionString),
                                                                    messageCount, runtime, timeOut, workerCount, readerCount, queueSize, false, x => { },
                                                                    Helpers.GenerateData, Helpers.Verify, VerifyQueueCount).ConfigureAwait(false);
        }
Esempio n. 2
0
 public async Task Run(int messageCount, int runtime, int timeOut, int workerCount, int readerCount, int queueSize)
 {
     using (var connectionInfo = new IntegrationConnectionInfo())
     {
         var consumer =
             new DotNetWorkQueue.IntegrationTests.Shared.ConsumerAsync.Implementation.MultiConsumerAsync();
         await consumer.Run <MemoryMessageQueueInit, MessageQueueCreation>(GetConnections(connectionInfo.ConnectionString),
                                                                           messageCount, runtime, timeOut, workerCount, readerCount, queueSize, false, x => { },
                                                                           Helpers.GenerateData, Helpers.Verify, VerifyQueueCount).ConfigureAwait(false);
     }
 }
 public async Task Run(int messageCount, int runtime, int timeOut, int workerCount, int readerCount, int queueSize,
                       bool useTransactions, bool enableChaos)
 {
     var queueName = GenerateQueueName.Create();
     var consumer  =
         new DotNetWorkQueue.IntegrationTests.Shared.ConsumerAsync.Implementation.MultiConsumerAsync();
     await consumer.Run <PostgreSqlMessageQueueInit, PostgreSqlMessageQueueCreation>(GetConnections(ConnectionInfo.ConnectionString),
                                                                                     messageCount, runtime, timeOut, workerCount, readerCount, queueSize, enableChaos, x => Helpers.SetOptions(x,
                                                                                                                                                                                               true, !useTransactions, useTransactions, false,
                                                                                                                                                                                               false, !useTransactions, true, false),
                                                                                     Helpers.GenerateData, Helpers.Verify, Helpers.VerifyQueueCount).ConfigureAwait(false);
 }
 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);
     }
 }