public async Task MixedQueuesAndQueueNamesTestBeanTest() { var queue1 = QueueBuilder.Durable("metaTestQueue").Build(); queue1.ServiceName = "queue1"; var queue2 = QueueBuilder.Durable("metaTestQueue2").Build(); var queues = new List <IQueue>() { queue1, queue2 }; var provider = await Config.CreateAndStartServices(null, queues, typeof(MixedQueuesAndQueueNamesTestBean)); var context = provider.GetService <IApplicationContext>(); var factory = context.GetService <IRabbitListenerContainerFactory>() as RabbitListenerContainerTestFactory; Assert.Single(factory.GetListenerContainers()); var container = factory.GetListenerContainers()[0] as MessageListenerTestContainer; var endpoint = container.Endpoint as AbstractRabbitListenerEndpoint; Assert.NotNull(endpoint); Assert.Equal(2, endpoint.QueueNames.Count); Assert.Contains("metaTestQueue", endpoint.QueueNames); Assert.Contains("metaTestQueue2", endpoint.QueueNames); }
public void Initialize(ExtensionConfigContext context) { _messageEnqueuedWatcherGetter = context.PerHostServices.GetService <ContextAccessor <IMessageEnqueuedWatcher> >(); _accountProvider = context.Config.GetService <IStorageAccountProvider>(); context.ApplyConfig(context.Config.Queues, "queues"); // IStorageQueueMessage is the core testing interface var binding = context.AddBindingRule <QueueAttribute>(); binding .AddConverter <byte[], IStorageQueueMessage>(ConvertByteArrayToCloudQueueMessage) .AddConverter <string, IStorageQueueMessage>(ConvertStringToCloudQueueMessage) .AddOpenConverter <OpenType.Poco, IStorageQueueMessage>(ConvertPocoToCloudQueueMessage); context // global converters, apply to multiple attributes. .AddConverter <IStorageQueueMessage, byte[]>(ConvertCloudQueueMessageToByteArray) .AddConverter <IStorageQueueMessage, string>(ConvertCloudQueueMessageToString) .AddConverter <CloudQueueMessage, IStorageQueueMessage>(ConvertToStorageQueueMessage); var builder = new QueueBuilder(this); binding.AddValidator(ValidateQueueAttribute); binding.SetPostResolveHook(ToWriteParameterDescriptorForCollector) .BindToCollector <IStorageQueueMessage>(this); binding.SetPostResolveHook(ToReadWriteParameterDescriptorForCollector) .BindToInput <IStorageQueue>(builder); binding.SetPostResolveHook(ToReadWriteParameterDescriptorForCollector) .BindToInput <CloudQueue>(builder); }
public void Initialize(ExtensionConfigContext context, QueueServiceClientProvider queueServiceClientProvider, IContextGetter <IMessageEnqueuedWatcher> contextGetter) { _queueServiceClientProvider = queueServiceClientProvider; _messageEnqueuedWatcherGetter = contextGetter; // TODO: FACAVAL replace this with queue options. This should no longer be needed. //context.ApplyConfig(context.Config.Queues, "queues"); // IStorageQueueMessage is the core testing interface var binding = context.AddBindingRule <QueueAttribute>(); binding .AddConverter <byte[], QueueMessage>(ConvertByteArrayToCloudQueueMessage) .AddConverter <string, QueueMessage>(ConvertStringToCloudQueueMessage) .AddOpenConverter <OpenType.Poco, QueueMessage>(ConvertPocoToCloudQueueMessage); context // global converters, apply to multiple attributes. .AddConverter <QueueMessage, byte[]>(ConvertCloudQueueMessageToByteArray) .AddConverter <QueueMessage, string>(ConvertCloudQueueMessageToString); var builder = new QueueBuilder(this); binding.AddValidator(ValidateQueueAttribute); binding.BindToCollector <QueueMessage>(this); binding.BindToInput <QueueClient>(builder); binding.BindToInput <QueueClient>(builder); }
public async Task SimpleMessageListener() { var queues = new List <IQueue>() { QueueBuilder.Durable("testQueue").Build(), QueueBuilder.Durable("secondQueue").Build() }; var provider = await Config.CreateAndStartServices(null, queues, typeof(SimpleMessageListenerTestBean)); var context = provider.GetService <IApplicationContext>(); var factory = context.GetService <IRabbitListenerContainerFactory>() as RabbitListenerContainerTestFactory; Assert.Single(factory.GetListenerContainers()); var container = factory.GetListenerContainers()[0] as MessageListenerTestContainer; var endpoint = container.Endpoint; Assert.IsType <MethodRabbitListenerEndpoint>(endpoint); var methodEndpoint = endpoint as MethodRabbitListenerEndpoint; Assert.NotNull(methodEndpoint.Instance); Assert.NotNull(methodEndpoint.Method); var listenerContainer = new DirectMessageListenerContainer(context); methodEndpoint.SetupListenerContainer(listenerContainer); Assert.NotNull(listenerContainer.MessageListener); Assert.True(container.IsStarted); provider.Dispose(); Assert.True(container.IsStopped); }
public void Initialize( ExtensionConfigContext context, QueueServiceClientProvider queueServiceClientProvider, IContextGetter <IMessageEnqueuedWatcher> contextGetter, QueueCausalityManager queueCausalityManager) { _queueServiceClientProvider = queueServiceClientProvider; _messageEnqueuedWatcherGetter = contextGetter; _queueCausalityManager = queueCausalityManager; // IStorageQueueMessage is the core testing interface var binding = context.AddBindingRule <QueueAttribute>(); binding .AddConverter <byte[], QueueMessage>(ConvertByteArrayToCloudQueueMessage) .AddConverter <string, QueueMessage>(ConvertStringToCloudQueueMessage) .AddConverter <BinaryData, QueueMessage>(ConvertBinaryDataToCloudQueueMessage) .AddOpenConverter <OpenType.Poco, QueueMessage>(ConvertPocoToCloudQueueMessage); context // global converters, apply to multiple attributes. .AddConverter <QueueMessage, byte[]>(ConvertCloudQueueMessageToByteArray) .AddConverter <QueueMessage, string>(ConvertCloudQueueMessageToString) .AddConverter <QueueMessage, BinaryData>(ConvertCloudQueueMessageToBinaryData); var builder = new QueueBuilder(this); binding.AddValidator(ValidateQueueAttribute); binding.BindToCollector <QueueMessage>(this); binding.BindToInput <QueueClient>(builder); binding.BindToInput <QueueClient>(builder); }
private MessageQueue GetMessageQueue(string queueName, bool transactional) { MessageQueue queue; IQueueBuilder builder; var queuePath = QueueBuilder.TryFormatPath(queueName); builder = QueueBuilder.New(queuePath) .WithJsonSerialization(); if (transactional) { builder.AsTransactional(); } if ((QueueBuilder.IsPrivateQueuePath(queuePath) && settings.CreateLocalQueues)) { queue = builder.TryCreate(); } else { queue = builder.Retrieve(); } return(queue); }
public void BuilderConfigAllSettings() { string path = @".\private$\MyQueue"; string desc = "Queue description"; var qbuilder = (QueueBuilder)QueueBuilder.New("MyQueue"); QueueSettings config; qbuilder .AsTransactional() .UseConnectionCache() .WithExclusiveReadAccess() .UseJournalQueue() .WithDescription(desc) .WithFormatter(new JsonFormatter()) .WithMaxJournalSize(1000) .WithMaxQueueSize(1000); config = qbuilder.settings; Assert.AreEqual(typeof(JsonFormatter), config.Formatter.GetType(), "Formatter"); Assert.AreEqual(desc, config.Label, "Label"); Assert.AreEqual(true, config.UseConnectionCache, "UseConnectionCache"); Assert.AreEqual(true, config.DenySharedReceive, "DenySharedReceive"); Assert.AreEqual(1000, config.MaxJournalQueueSize, "MaxJournalQueueSize"); Assert.AreEqual(1000, config.MaxQueueSize, "MaxQueueSize"); Assert.AreEqual(path, config.Path, "Path"); Assert.AreEqual(true, config.Transactional, "Transactional"); Assert.AreEqual(true, config.UseJournalQueue, "UseJournalQueue"); }
private MessageQueue GetMessageQueue(string queueName, bool denySharedReceive) { MessageQueue queue; var queuePath = QueueBuilder.TryFormatPath(queueName); IQueueBuilder builder = QueueBuilder.New(queuePath) .WithExclusiveReadAccess() .WithJsonSerialization(); if (denySharedReceive) { builder.WithExclusiveReadAccess(); } if ((QueueBuilder.IsPrivateQueuePath(queuePath) && settings.AutoCreateLocalQueues)) { queue = builder.TryCreate(); } else { queue = builder.Retrieve(); } return(queue); }
public static void AddMongoQueue <TRegistrator>(this IServiceCollection services, Action <MongoQueueConfig> configure) where TRegistrator : IMessagingDependencyRegistrator, new() { var queueBuilder = new QueueBuilder().AddRegistrator <TRegistrator>(services); var config = new MongoQueueConfig(queueBuilder); configure(config); queueBuilder.AddResolver().Build(); }
public void BuilderConfigDefaultFormatter() { string path = @".\Private$\MyQueue"; var qbuilder = (QueueBuilder)QueueBuilder.New(path); QueueSettings config; config = qbuilder.settings; Assert.IsNull(config.Formatter, "Formatter"); }
public void BuilderConfigJsonFormatter() { string path = @".\Private$\MyQueue"; var qbuilder = (QueueBuilder)QueueBuilder.New(path); QueueSettings config; qbuilder.WithJsonSerialization(); config = qbuilder.settings; Assert.AreEqual(typeof(JsonFormatter), config.Formatter.GetType(), "Formatter"); }
static async Task DoStuff() { var containerBuilder = new ContainerBuilder(); var builder = new QueueBuilder(); builder .AddRegistrator <MessagingDependencyRegistrator>() .AddResolver() .AddAutofac(containerBuilder) .Build(); var container = containerBuilder.Build(); var queue = container.Resolve <QueueProvider>(); var publisher = queue.GetPublisher(); while (true) { try { var rnd = new Random(DateTime.Now.Millisecond); var id = rnd.Next(); var guid = Guid.NewGuid().ToString(); if (id % 2 == 0) { if (id % 4 == 0) { var message = new DomainMessage(guid, "exception"); await publisher.PublishAsync(message); } else { var message = new DomainMessage(guid, rnd.Next().ToString()); await publisher.PublishAsync(message); } } else { var message = new AnotherDomainMessage(guid, rnd.Next().ToString(), "waddap indeed"); await publisher.PublishAsync(message); } } catch (Exception e) { Console.WriteLine(e.ToString()); await Task.Delay(500); } } }
public async Task InvalidValueInAnnotationTestBeanTest() { var queue1 = QueueBuilder.Durable("metaTestQueue").Build(); queue1.ServiceName = "queue1"; var queue2 = QueueBuilder.Durable("metaTestQueue2").Build(); queue2.ServiceName = "queue2"; var queues = new List <IQueue>() { queue1, queue2 }; var excep = await Assert.ThrowsAsync <ExpressionException>(() => Config.CreateAndStartServices(null, queues, typeof(InvalidValueInAnnotationTestBean))); }
public static async Task <ServiceProvider> CreateAndStartServices() { var mockConnectionFactory = new Mock <IConnectionFactory>(); var mockConnection = new Mock <IConnection>(); var mockChannel = new Mock <R.IModel>(); mockConnectionFactory.Setup(f => f.CreateConnection()).Returns(mockConnection.Object); mockConnection.Setup(c => c.CreateChannel(It.IsAny <bool>())).Returns(mockChannel.Object); mockChannel.Setup((c) => c.CreateBasicProperties()).Returns(new MockRabbitBasicProperties()); mockConnection.Setup((c) => c.IsOpen).Returns(true); mockChannel.Setup((c) => c.IsOpen).Returns(true); var queueName = new AtomicReference <string>(); mockChannel.Setup(c => c.QueueDeclarePassive(It.IsAny <string>())).Returns(() => new R.QueueDeclareOk(queueName.Value, 0, 0)) .Callback <string>((name) => queueName.Value = name); var services = new ServiceCollection(); var config = new ConfigurationBuilder().Build(); services.AddSingleton <IConfiguration>(config); services.AddRabbitHostingServices(); services.AddRabbitMessageHandlerMethodFactory(); services.AddRabbitListenerAttributeProcessor(); services.AddRabbitDefaultMessageConverter(); services.AddRabbitListenerEndpointRegistry(); services.AddRabbitListenerEndpointRegistrar(); services.AddSingleton <IConnectionFactory>(mockConnectionFactory.Object); services.AddRabbitListenerContainerFactory <TestDirectRabbitListenerContainerFactory>("rabbitListenerContainerFactory"); services.AddRabbitAdmin(); var myQueue = QueueBuilder.Durable("myQueue").Build(); var anotherQueue = QueueBuilder.Durable("anotherQueue").Build(); var class1 = QueueBuilder.Durable("class1").Build(); var class2 = QueueBuilder.Durable("class2").Build(); services.AddRabbitQueues(myQueue, anotherQueue, class1, class2); services.AddSingleton <RabbitListenersBean>(); services.AddSingleton <ClassLevelListenersBean>(); services.AddRabbitListeners(config, typeof(RabbitListenersBean), typeof(ClassLevelListenersBean)); var container = services.BuildServiceProvider(); await container.GetRequiredService <IHostedService>().StartAsync(default);
public async Task SimpleMessageListenerWithMixedAnnotations() { var configBuilder = new ConfigurationBuilder(); configBuilder.AddInMemoryCollection(new Dictionary <string, string>() { { "rabbit:myQueue", "secondQueue" } }); var config = configBuilder.Build(); var queues = new List <IQueue>() { QueueBuilder.Durable("testQueue").Build(), QueueBuilder.Durable("secondQueue").Build() }; var provider = await Config.CreateAndStartServices(config, queues, typeof(SimpleMessageListenerWithMixedAnnotationsTestBean)); var context = provider.GetService <IApplicationContext>(); var factory = context.GetService <IRabbitListenerContainerFactory>() as RabbitListenerContainerTestFactory; Assert.Single(factory.GetListenerContainers()); var container = factory.GetListenerContainers()[0]; var endpoint = container.Endpoint; Assert.IsType <MethodRabbitListenerEndpoint>(endpoint); var methodEndpoint = endpoint as MethodRabbitListenerEndpoint; Assert.NotNull(methodEndpoint.Instance); Assert.NotNull(methodEndpoint.Method); Assert.Equal(2, methodEndpoint.QueueNames.Count); Assert.Contains("testQueue", methodEndpoint.QueueNames); Assert.Contains("secondQueue", methodEndpoint.QueueNames); var listenerContainer = new DirectMessageListenerContainer(context); methodEndpoint.SetupListenerContainer(listenerContainer); Assert.NotNull(listenerContainer.MessageListener); Assert.True(container.IsStarted); provider.Dispose(); Assert.True(container.IsStopped); }
public void Initialize(ExtensionConfigContext context, StorageAccountProvider storageAccountProvider, IContextGetter <IMessageEnqueuedWatcher> contextGetter) { _accountProvider = storageAccountProvider; _messageEnqueuedWatcherGetter = contextGetter; // TODO: FACAVAL replace this with queue options. This should no longer be needed. //context.ApplyConfig(context.Config.Queues, "queues"); // IStorageQueueMessage is the core testing interface var binding = context.AddBindingRule <QueueAttribute>(); binding .AddConverter <byte[], QueueMessage>(ConvertByteArrayToCloudQueueMessage) .AddConverter <string, QueueMessage>(ConvertStringToCloudQueueMessage) .AddOpenConverter <OpenType.Poco, QueueMessage>(ConvertPocoToCloudQueueMessage); context // global converters, apply to multiple attributes. .AddConverter <QueueMessage, byte[]>(ConvertCloudQueueMessageToByteArray) .AddConverter <QueueMessage, string>(ConvertCloudQueueMessageToString); var builder = new QueueBuilder(this); binding.AddValidator(ValidateQueueAttribute); #pragma warning disable CS0618 // Type or member is obsolete binding.SetPostResolveHook(ToWriteParameterDescriptorForCollector) #pragma warning restore CS0618 // Type or member is obsolete .BindToCollector <QueueMessage>(this); #pragma warning disable CS0618 // Type or member is obsolete binding.SetPostResolveHook(ToReadWriteParameterDescriptorForCollector) #pragma warning restore CS0618 // Type or member is obsolete .BindToInput <QueueClient>(builder); #pragma warning disable CS0618 // Type or member is obsolete binding.SetPostResolveHook(ToReadWriteParameterDescriptorForCollector) #pragma warning restore CS0618 // Type or member is obsolete .BindToInput <QueueClient>(builder); }
public async Task PropertyPlaceholderResolvingToQueueTestBeanTest() { var configBuilder = new ConfigurationBuilder(); configBuilder.AddInMemoryCollection(new Dictionary <string, string>() { { "rabbit:myQueue", "#{@queue1}" } }); var config = configBuilder.Build(); var queue1 = QueueBuilder.Durable("metaTestQueue").Build(); queue1.ServiceName = "queue1"; var queue2 = QueueBuilder.Durable("metaTestQueue2").Build(); queue2.ServiceName = "queue2"; var queues = new List <IQueue>() { queue1, queue2 }; var provider = await Config.CreateAndStartServices(config, queues, typeof(PropertyPlaceholderResolvingToQueueTestBean)); var context = provider.GetService <IApplicationContext>(); var factory = context.GetService <IRabbitListenerContainerFactory>() as RabbitListenerContainerTestFactory; Assert.Single(factory.GetListenerContainers()); var container = factory.GetListenerContainers()[0] as MessageListenerTestContainer; var endpoint = container.Endpoint as AbstractRabbitListenerEndpoint; Assert.NotNull(endpoint); Assert.Equal(2, endpoint.QueueNames.Count); Assert.Contains("metaTestQueue", endpoint.QueueNames); Assert.Contains("metaTestQueue2", endpoint.QueueNames); }
public static QueueBuilder AddAutofac(this QueueBuilder queue, ContainerBuilder builder) { builder.Populate(queue.Registrator); return(queue); }
/// <summary> /// Включает использование брокера <c>RabbitMQ</c>. /// </summary> /// <param name="busConfigurator">Конфигуратор шины сообщений.</param> /// <returns>Конфигуратор шины сообщений с включенной поддержкой брокера.</returns> public static IBusConfigurator UseRabbitMq(this IBusConfigurator busConfigurator) { var c = (BusConfiguration)busConfigurator; if (c.BusFactoryFunc != null) { return(busConfigurator); } c.BuildBusUsing(bc => new RabbitBus(c)); var blockedHeaders = new List <string> { Headers.Expires, Headers.MessageLabel, Headers.Persist, Headers.QueueMessageTtl, Headers.ReplyRoute, Headers.Timeout, Headers.Ttl, Headers.Delay }; var messageHeaderStorage = new MessageHeaderStorage(blockedHeaders); c.UseIncomingMessageHeaderStorage(messageHeaderStorage); c.SenderDefaults = new RabbitSenderOptions(c.EndpointOptions) { ConfirmationIsRequired = false, Persistently = false, RequestTimeout = TimeSpan.FromSeconds(30), Ttl = default(TimeSpan?), RouteResolverBuilder = RabbitBusDefaults.RouteResolverBuilder, ReuseConnection = true, ProducerSelectorBuilder = RabbitBusDefaults.ProducerSelectorBuilder, FailoverAttempts = 7, MaxRetryDelay = 30, InactivityResetDelay = 120 }; c.ReceiverDefaults = new RabbitReceiverOptions(c.EndpointOptions) { AcceptIsRequired = false, ParallelismLevel = 1, EndpointBuilder = RabbitBusDefaults.SubscriptionEndpointBuilder, QoS = new QoSParams(50, 0), ReuseConnection = true }; c.UseMessageLabelHandler(new DefaultRabbitMessageLabelHandler()); // TODO: extract, combine routing and handler definition Func <IRouteResolverBuilder, IRouteResolver> faultRouteResolverBuilder = b => { TimeSpan messageTtl = c.ReceiverDefaults.GetFaultQueueTtl().HasValue ? c.ReceiverDefaults.GetFaultQueueTtl().Value : TimeSpan.FromDays(FaultMessageTtlDays); string name = b.Endpoint.Address + ".Fault"; Exchange e = b.Topology.Declare(Exchange.Named(name).Durable.Topic); QueueBuilder builder = Queue.Named(name).Durable.WithTtl(messageTtl); if (c.ReceiverDefaults.GetFaultQueueLimit().HasValue) { builder = builder.WithLimit(c.ReceiverDefaults.GetFaultQueueLimit().Value); } Queue q = b.Topology.Declare(builder); b.Topology.Bind(e, q); return(e); }; c.Route("document.Contour.unhandled").Persistently().ConfiguredWith(faultRouteResolverBuilder).ReuseConnection(); c.Route("document.Contour.failed").Persistently().ConfiguredWith(faultRouteResolverBuilder).ReuseConnection(); c.OnUnhandled( d => { d.Forward("document.Contour.unhandled", d.BuildFaultMessage()); d.Accept(); }); c.OnFailed( d => { d.Forward("document.Contour.failed", d.BuildFaultMessage()); d.Accept(); }); return(busConfigurator); }
internal MongoQueueConfig(QueueBuilder queueBuilder) { _queueBuilder = queueBuilder; }
static void Main(string[] args) { try { jsonMessageList jsonList = new jsonMessageList(); jsonList.iterateList(); ShowBindings(); //return; _mBuilder = new MainBuilder(); _mBuilder.doWork(); //Checking Binding to an Exchange - Surviving Channel ExchangeBuilder exBuilder = new ExchangeBuilder(); QueueBuilder qBuilder = new QueueBuilder(); RPCBuilder rPCBuilder = new RPCBuilder(); exBuilder.createExchange(_mBuilder.Channel, "ChannelTimeoutChecker_EX"); qBuilder.createQueue(_mBuilder.Channel, "ChannelTimeoutListener"); qBuilder.createQueue(_mBuilder.Channel, "rpcReplyQueue"); qBuilder.BindToExchange(_mBuilder.Channel, "ChannelTimeoutChecker_EX", "ChannelTimeoutListener"); rPCBuilder.createRPC(_mBuilder.Channel, "rpcQueue"); // for (int i = 0 ;i < 100;i++) // { // ConnectionChannelChecking(i.ToString()); // if(i % 20 == 0) // { // ThreadPool.QueueUserWorkItem(SendToExchange,_mBuilder.Channel); // } // } // ThreadPool.QueueUserWorkItem(SendToExchange,_mBuilder.Channel); // ThreadPool.QueueUserWorkItem(SendToExchange,_mBuilder.Channel); // ThreadPool.QueueUserWorkItem(SendToExchange,_mBuilder.Channel); // ThreadPool.QueueUserWorkItem(SendToExchange,_mBuilder.Channel); // ThreadPool.QueueUserWorkItem(SendToExchange,_mBuilder.Channel); // Thread.Sleep(60000); // Console.WriteLine("end thread"); // _stopThread = true; // Thread.Sleep(2000); // Console.WriteLine("did it ended?"); // RPC Call var rpcClient = new RpcClient(); rpcClient.consumeReplyQueue(_mBuilder.Channel, "rpcReplyQueue"); string result = rpcClient.Call("1", "rpcQueue"); Console.WriteLine("RPC Result: " + result); //Ende RPC for (int i = 0; i < 10; i++) { putMessages("WorkingQueue_" + i.ToString().PadLeft(2, '0')); } // Console.WriteLine("open a thread to listen to exchange"); //ThreadPool.QueueUserWorkItem(listenToExchange,_mBuilder.Channel); // Consumer consumer1 = new Consumer(); // consumer1.Subscribe("logs7even0","Consumer 1","..1.."); //Consumer consumer2 = new Consumer(); //consumer2.Subscribe("logs7even","Consumer 2","..2.."); // consumer1.Subscribe("logs7even1","Consumer 2","..2.."); // GetMessaging getMessages = new GetMessaging(); // getMessages.GetMessage(_mBuilder.Channel, "WorkingQueue_03"); // Console.WriteLine("i am really finished"); // putExchangeMessages("logs7even0"); // Thread.Sleep(500); // putExchangeMessages("logs7even0"); // Thread.Sleep(500); // putExchangeMessages("logs7even0"); // Thread.Sleep(500); // putExchangeMessages("logs7even0"); // for(int i = 0; i < 50 ;i ++) // { // putExchangeMessages("logs7even0"); // putExchangeMessages("logs7even1","Sending TOO SECOND"); // Thread.Sleep(500); // } } catch (Exception ex) { Console.WriteLine("Fehler: " + ex.Message); } finally { Console.WriteLine("fertig"); Console.ReadLine(); } }
public void SetUp() { _queueRepositoryMock = new Mock <IQueueRepository>(MockBehavior.Strict); _queueBuilder = new QueueBuilder(_queueRepositoryMock.Object); }
public void ShouldSetupLimit() { QueueBuilder sut = new QueueBuilder("queue").WithLimit(1000); Assert.AreEqual(1000, sut.Instance.Limit, "Should be set correct limit of message amount."); }
public void BuilderConfigNullPathValidation() { var qbuilder = (QueueBuilder)QueueBuilder.New(string.Empty); qbuilder.settings.Validate(); }