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();
}
