コード例 #1
0
 public void Run(
     int messageCount,
     bool interceptors)
 {
     using (var connectionInfo = new IntegrationConnectionInfo())
     {
         var queueName = GenerateQueueName.Create();
         var producer  = new DotNetWorkQueue.IntegrationTests.Shared.Producer.Implementation.SimpleProducer();
         producer.Run <MemoryMessageQueueInit, FakeMessage, MessageQueueCreation>(new QueueConnection(queueName,
                                                                                                      connectionInfo.ConnectionString),
                                                                                  messageCount, interceptors, false, false, x => { },
                                                                                  Helpers.GenerateData, Helpers.Verify);
     }
 }
コード例 #2
0
 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);
     }
 }
コード例 #3
0
        public void Run(
            int messageCount,
            bool interceptors,
            bool enableDelayedProcessing,
            bool enableHeartBeat,
            bool enableHoldTransactionUntilMessageCommitted,
            bool enableMessageExpiration,
            bool enablePriority,
            bool enableStatus,
            bool enableStatusTable,
            bool additionalColumn,
            bool enableChaos)
        {
            var queueName = GenerateQueueName.Create();
            var producer  = new DotNetWorkQueue.IntegrationTests.Shared.Producer.Implementation.SimpleProducer();

            producer.Run <SqlServerMessageQueueInit, FakeMessage, SqlServerMessageQueueCreation>(new QueueConnection(queueName, ConnectionInfo.ConnectionString),
                                                                                                 messageCount, interceptors, enableChaos, false, x => Helpers.SetOptions(x,
                                                                                                                                                                         enableDelayedProcessing, enableHeartBeat, enableHoldTransactionUntilMessageCommitted,
                                                                                                                                                                         enableMessageExpiration,
                                                                                                                                                                         enablePriority, enableStatus, enableStatusTable, additionalColumn),
                                                                                                 Helpers.GenerateData, Helpers.Verify);
        }
コード例 #4
0
        public void Run(
            int messageCount,
            bool interceptors,
            bool batchSending,
            bool enableDelay,
            bool enableExpiration,
            ConnectionInfoTypes type)
        {
            var queueName        = GenerateQueueName.Create();
            var connectionString = new ConnectionInfo(type).ConnectionString;
            var producer         = new DotNetWorkQueue.IntegrationTests.Shared.Producer.Implementation.SimpleProducer();

            if (enableExpiration && enableDelay)
            {
                producer.Run <RedisQueueInit, FakeMessage, RedisQueueCreation>(new QueueConnection(queueName, connectionString),
                                                                               messageCount, interceptors, false, batchSending, x => { },
                                                                               Helpers.GenerateDelayExpiredData, Helpers.Verify);
            }
            else if (enableDelay)
            {
                producer.Run <RedisQueueInit, FakeMessage, RedisQueueCreation>(new QueueConnection(queueName, connectionString),
                                                                               messageCount, interceptors, false, batchSending, x => { },
                                                                               Helpers.GenerateDelayData, Helpers.Verify);
            }
            else if (enableExpiration)
            {
                producer.Run <RedisQueueInit, FakeMessage, RedisQueueCreation>(new QueueConnection(queueName, connectionString),
                                                                               messageCount, interceptors, false, batchSending, x => { },
                                                                               Helpers.GenerateExpiredData, Helpers.Verify);
            }
            else
            {
                producer.Run <RedisQueueInit, FakeMessage, RedisQueueCreation>(new QueueConnection(queueName, connectionString),
                                                                               messageCount, interceptors, false, batchSending, x => { },
                                                                               Helpers.GenerateData, Helpers.Verify);
            }
        }
コード例 #5
0
 public void Run(
     int messageCount,
     bool interceptors,
     bool enableDelayedProcessing,
     bool enableHeartBeat,
     bool enableMessageExpiration,
     bool enablePriority,
     bool enableStatus,
     bool enableStatusTable,
     bool additionalColumn,
     bool inMemoryDb,
     bool enableChaos)
 {
     using (var connectionInfo = new IntegrationConnectionInfo(inMemoryDb))
     {
         var queueName = GenerateQueueName.Create();
         var producer  = new DotNetWorkQueue.IntegrationTests.Shared.Producer.Implementation.SimpleProducer();
         producer.Run <SqLiteMessageQueueInit, FakeMessage, SqLiteMessageQueueCreation>(new QueueConnection(queueName, connectionInfo.ConnectionString),
                                                                                        messageCount, interceptors, enableChaos, true, x => Helpers.SetOptions(x,
                                                                                                                                                               enableDelayedProcessing, enableHeartBeat, enableMessageExpiration,
                                                                                                                                                               enablePriority, enableStatus, enableStatusTable, additionalColumn),
                                                                                        Helpers.GenerateData, Helpers.Verify);
     }
 }