public void UseXmlFormat_MessageSent_Received()
{
ManualResetEvent ev = new ManualResetEvent(false);
using (IBus busA = new RabbitMQBus(), busB = new RabbitMQBus())
{
Person person = new Person
{
Id = 5
};
Person actual = null;
using (ISubscriber subscriber = busA.CreateSubscriber())
{
subscriber.Subscribe((Action <Person>)(p =>
{
actual = p;
ev.Set();
}));
subscriber.Open();
using (IPublisher publisher = busB.CreatePublisher(c => c.UseXmlSerializer()))
{
publisher.Send(person);
}
ev.WaitOne(TimeSpan.FromSeconds(5));
actual.ShouldBeEquivalentTo(person);
}
}
}
public void Bus_PublishMessage_MonitorReceive()
{
ManualResetEvent ev = new ManualResetEvent(false);
using (IBus bus = new RabbitMQBus())
{
Action <SerializedBusMessage> action = message =>
{
ev.Set();
};
using (ISubscription monitor = bus.CreateMonitor(action))
{
monitor.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(new Person
{
Id = 34
});
}
var waitOne = ev.WaitOne(TimeSpan.FromSeconds(10));
Assert.IsTrue(waitOne);
}
}
}
public void Bus_MakeSyncRpcCall_NoFastReply_CustomExchange()
{
using (IBus bus = new RabbitMQBus(c => c.SetReceiveSelfPublish()))
{
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.SetReplyExchange("amq.direct")))
{
subscriber.Subscribe((RequestMessage m) => new ResponseMessage
{
Code = m.Data.Length
});
subscriber.Open();
using (IRpcPublisher rpcPublisher = bus.CreateRpcPublisher(c => c.DisableFastReply().SetReplyExchange("amq.direct").SetReplyTo("MyReplyKey")))
{
ResponseMessage response = rpcPublisher.Send <RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "Hello, world!"
}, TimeSpan.FromSeconds(10));
response.ShouldBeEquivalentTo(new ResponseMessage
{
Code = 13
});
}
}
}
}
public void Bus_PublishMessage_MonitorReceive()
{
ManualResetEvent ev = new ManualResetEvent(false);
using (IBus bus = new RabbitMQBus())
{
Action<RawBusMessage> action = message =>
{
ev.Set();
};
using (ISubscription monitor = bus.CreateMonitor(action))
{
monitor.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(new Person
{
Id = 34
});
}
var waitOne = ev.WaitOne(TimeSpan.FromSeconds(10));
Assert.IsTrue(waitOne);
}
}
}
public EventsConsumer(IConfiguration config, ServerState state)
{
_state = state;
var gameConsumerBus = new RabbitMQBus(config["RabbitServer"], "games-list", "game-ex");
gameConsumerBus.Consumer(GameEventsConsumer);
}
public void Bus_MakeRpcCall_RejectedByHandler()
{
using (IBus bus = new RabbitMQBus(c => c.SetReceiveSelfPublish()))
{
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.UseTransactionalDelivery()))
{
subscriber.Subscribe((RequestMessage m) =>
{
throw new RejectMessageException();
});
subscriber.Open();
using (IRpcAsyncPublisher rpcPublisher = bus.CreateAsyncRpcPublisher())
{
try
{
var task = rpcPublisher.Send <RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "Hello, world!"
}, TimeSpan.FromSeconds(10));
task.Wait(TimeSpan.FromSeconds(30));
Assert.Fail("No exception");
}
catch (AggregateException ex) when(ex.InnerException is RpcCallException)
{
(ex.InnerException as RpcCallException).Reason.Should().Be(RpcFailureReason.Reject);
}
}
}
}
}
public void Bus_MakeRpcCall_ExceptionOnHandler()
{
using (IBus bus = new RabbitMQBus(c => c.SetReceiveSelfPublish()))
{
using (ISubscriber subscriber = bus.CreateSubscriber())
{
subscriber.Subscribe((RequestMessage m) => {
throw new Exception("ooops");
});
subscriber.Open();
using (IRpcPublisher rpcPublisher = bus.CreateRpcPublisher())
{
try
{
rpcPublisher.Send<RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "Hello, world!"
}, TimeSpan.FromSeconds(10));
Assert.Fail("No exception");
}
catch (RpcCallException ex)
{
ex.Reason.Should().Be(RpcFailureReason.HandlerError);
}
}
}
}
}
public void Bus_MakeRpcCall_ExceptionOnHandler()
{
using (IBus bus = new RabbitMQBus(c => c.SetReceiveSelfPublish()))
{
using (ISubscriber subscriber = bus.CreateSubscriber())
{
subscriber.Subscribe((RequestMessage m) => {
throw new Exception("ooops");
});
subscriber.Open();
using (IRpcPublisher rpcPublisher = bus.CreateRpcPublisher())
{
try
{
rpcPublisher.Send <RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "Hello, world!"
}, TimeSpan.FromSeconds(10));
Assert.Fail("No exception");
}
catch (RpcCallException ex)
{
ex.Reason.Should().Be(RpcFailureReason.HandlerError);
}
}
}
}
}
public async Task Bus_MakeRpcCall()
{
using (IBus bus = new RabbitMQBus(c => c.SetReceiveSelfPublish()))
{
using (ISubscriber subscriber = bus.CreateSubscriber())
{
subscriber.Subscribe((RequestMessage m) => new ResponseMessage
{
Code = m.Data.Length
});
subscriber.Open();
using (IRpcAsyncPublisher rpcPublisher = bus.CreateAsyncRpcPublisher())
{
ResponseMessage response = await rpcPublisher.Send <RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "Hello, world!"
}, TimeSpan.FromSeconds(10));
response.ShouldBeEquivalentTo(new ResponseMessage
{
Code = 13
});
}
}
}
}
public void Bus_MakeRpcVoidCall_SubscriberReturnData()
{
using (IBus bus = new RabbitMQBus(c => c.SetReceiveSelfPublish()))
{
using (ISubscriber subscriber = bus.CreateSubscriber())
{
RequestMessage actual = null;
subscriber.Subscribe((RequestMessage m) =>
{
actual = m;
return(new ResponseMessage());
});
subscriber.Open();
using (IRpcAsyncPublisher rpcPublisher = bus.CreateAsyncRpcPublisher())
{
var expected = new RequestMessage
{
Data = "Hello, world!"
};
var task = rpcPublisher.Send(expected, TimeSpan.FromSeconds(10));
task.Wait(TimeSpan.FromSeconds(30));
actual.ShouldBeEquivalentTo(expected);
}
}
}
}
public async Task Bus_MakeRpcCall_TimeOutOnReply()
{
using (IBus bus = new RabbitMQBus(c => c.SetReceiveSelfPublish()))
{
using (ISubscriber subscriber = bus.CreateSubscriber())
{
subscriber.Subscribe((RequestMessage m) => Thread.Sleep(TimeSpan.FromSeconds(20)));
subscriber.Open();
using (IRpcAsyncPublisher rpcPublisher = bus.CreateAsyncRpcPublisher())
{
try
{
await rpcPublisher.Send <RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "Hello, world!"
}, TimeSpan.FromSeconds(10));
Assert.Fail("No exception");
}
catch (RpcCallException ex)
{
ex.Reason.Should().Be(RpcFailureReason.TimeOut);
}
}
}
}
}
public void Send_Receive_Message()
{
using (IBus bus = new RabbitMQBus())
{
using (IChannelFactory <ITestContract> channelFactory = new MessageBus.Core.Proxy.ChannelFactory <ITestContract>(bus))
{
ISubscriptionFactory <ITestContract> subscriptionFactory = new SubscriptionFactory <ITestContract>(bus, c => c.SetReceiveSelfPublish());
string actual = "";
ManualResetEvent ev = new ManualResetEvent(false);
using (ISubscriptionSelector <ITestContract> selector = subscriptionFactory.Subscribe())
{
selector.Subscribe <string>(contract => contract.Foo, s =>
{
actual = s;
ev.Set();
});
ITestContract channel = channelFactory.CreateChannel();
channel.Foo("boo");
ev.WaitOne(TimeSpan.FromSeconds(5));
actual.Should().Be("boo");
}
}
}
}
public void Send_Receive_Message()
{
using (IBus bus = new RabbitMQBus())
{
using (IChannelFactory<ITestContract> channelFactory = new MessageBus.Core.Proxy.ChannelFactory<ITestContract>(bus))
{
ISubscriptionFactory<ITestContract> subscriptionFactory = new SubscriptionFactory<ITestContract>(bus, c => c.SetReceiveSelfPublish());
string actual = "";
ManualResetEvent ev = new ManualResetEvent(false);
using (ISubscriptionSelector<ITestContract> selector = subscriptionFactory.Subscribe())
{
selector.Subscribe<string>(contract => contract.Foo, s =>
{
actual = s;
ev.Set();
});
ITestContract channel = channelFactory.CreateChannel();
channel.Foo("boo");
ev.WaitOne(TimeSpan.FromSeconds(5));
actual.Should().Be("boo");
}
}
}
}
public async void Bus_MakeRpcCall()
{
using (IBus bus = new RabbitMQBus(c => c.SetReceiveSelfPublish()))
{
using (ISubscriber subscriber = bus.CreateSubscriber())
{
subscriber.Subscribe((RequestMessage m) => new ResponseMessage
{
Code = m.Data.Length
});
subscriber.Open();
using (IRpcAsyncPublisher rpcPublisher = bus.CreateAsyncRpcPublisher())
{
ResponseMessage response = await rpcPublisher.Send<RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "Hello, world!"
}, TimeSpan.FromSeconds(10));
response.ShouldBeEquivalentTo(new ResponseMessage
{
Code = 13
});
}
}
}
}
public void Setup()
{
bus1 = new RabbitMQBus(Environment.GetEnvironmentVariable("RUNZ_TEST_RABBITMQ_SERVER") ?? "localhost");
bus2 = new RabbitMQBus(Environment.GetEnvironmentVariable("RUNZ_TEST_RABBITMQ_SERVER") ?? "localhost");
bus1.PurgeQueue(q1);
bus1.PurgeQueue(q2);
}
public void MessageProcessFailedOnce_RejectMessageUsingExceptionFilter_CheckMessageDeliveredToDeadLetterQ()
{
using (RabbitMQBus entityA = new RabbitMQBus(), entityB = new RabbitMQBus(), entityC = new RabbitMQBus(c => c.UseConnectionString("amqp://localhost/amq.direct")))
{
TransactionalPerson message = new TransactionalPerson
{
Id = 5
};
ManualResetEvent ev = new ManualResetEvent(false);
int counter = 0;
BusMessage <TransactionalPerson> actual = null;
using (ISubscriber subscriberA = entityA.CreateSubscriber(c => c.UseDurableQueue(QueueName).UseTransactionalDelivery(new MyFilter())))
{
subscriberA.Subscribe((Action <TransactionalPerson>)(d =>
{
counter++;
throw new Exception();
}));
subscriberA.Open();
using (ISubscriber deadLetterSubscriber = entityC.CreateSubscriber(c => c.UseDurableQueue(DeadLetterQueueName)))
{
deadLetterSubscriber.Subscribe <TransactionalPerson>(m =>
{
actual = m;
ev.Set();
});
deadLetterSubscriber.Open();
const int expected = 2;
using (IPublisher publisher = entityB.CreatePublisher())
{
publisher.Send(message);
}
bool waitOne = ev.WaitOne(TimeSpan.FromSeconds(50));
counter.Should().BeGreaterOrEqualTo(expected);
waitOne.Should().BeTrue();
actual.Data.ShouldBeEquivalentTo(message);
XDeadHeader xDeadHeader = actual.Headers.OfType <XDeadHeader>().First();
xDeadHeader.Exchange.Should().Be("amq.headers");
xDeadHeader.Reason.Should().Be("rejected");
xDeadHeader.Queue.Should().Be(QueueName);
}
}
}
}
public void Bus_MultiClientRpcCall()
{
using (IBus serviceBus = new RabbitMQBus(), client1Bus = new RabbitMQBus(), client2Bus = new RabbitMQBus())
{
using (ISubscriber subscriber = serviceBus.CreateSubscriber())
{
subscriber.Subscribe((RequestMessage m) => new ResponseMessage
{
Code = int.Parse(m.Data)
});
subscriber.Open();
const int calls = 20;
using (IRpcPublisher rpcPublisher1 = client1Bus.CreateRpcPublisher(), rpcPublisher2 = client2Bus.CreateRpcPublisher())
{
List <ResponseMessage> c1Responses = new List <ResponseMessage>(), c2Responses = new List <ResponseMessage>();
Task t1 = Task.Factory.StartNew(() =>
{
for (int i = 0; i < calls; i++)
{
ResponseMessage response =
rpcPublisher1.Send <RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "1"
}, TimeSpan.FromSeconds(10));
c1Responses.Add(response);
}
});
Task t2 = Task.Factory.StartNew(() =>
{
for (int i = 0; i < calls; i++)
{
ResponseMessage response =
rpcPublisher2.Send <RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "2"
}, TimeSpan.FromSeconds(10));
c2Responses.Add(response);
}
});
Task.WaitAll(t1, t2);
c1Responses.Should().HaveCount(calls);
c2Responses.Should().HaveCount(calls);
c1Responses.All(message => message.Code == 1).Should().BeTrue();
c2Responses.All(message => message.Code == 2).Should().BeTrue();
}
}
}
}
public CourseRepository(ILogger logger
, IGenericsDbContextRepository <Models.Course> courseDbContextRepo
, RabbitMQBus messagingServiceBus)
{
_logger = logger;
_courseDbContextRepo = courseDbContextRepo;
_messagingServiceBus = messagingServiceBus;
}
public void RabbitMQBus_SetConnectionName_RabbitMQBusConnectionNameWasSet()
{
var expectedName = "test name";
using (IBus bus = new RabbitMQBus(c => c.SetConnectionProvidedName(expectedName)))
{
Assert.AreEqual(expectedName, bus.BusConnectionName);
}
}
public CourseStudentController(
ICourseStudentRepository courseStudentRepository,
ILogger logger,
RabbitMQBus mqServiceBus)
{
_courseStudentRepo = courseStudentRepository;
_logger = logger;
_mqServiceBus = mqServiceBus;
}
public void Start()
{
using (var scope1 = serviceProvider.CreateScope())
{
var p = scope1.ServiceProvider;
RabbitMQBus bus = this.serviceProvider.GetService <RabbitMQBus>();
bus.Start();
}
}
public void Clean()
{
using (var bus = new RabbitMQBus())
{
using (IRouteManager routeManager = bus.CreateRouteManager())
{
routeManager.DeleteQueue(QueueName);
routeManager.DeleteQueue(DeadLetterQueueName);
}
}
}
public void Clean()
{
using (var bus = new RabbitMQBus())
{
using (IRouteManager routeManager = bus.CreateRouteManager())
{
routeManager.DeleteQueue(QueueName);
routeManager.DeleteQueue(DeadLetterQueueName);
}
}
}
public RabbitMQHubLifetimeManager(ILoggerFactory loggerFactory,
ILogger <RabbitMQHubLifetimeManager <THub> > logger,
IOptions <RabbitMQOptions> options,
IHubProtocolResolver hubProtocolResolver)
{
_logger = logger;
_bus = new RabbitMQBus(options.Value,
new RabbitMQProtocol(hubProtocolResolver.AllProtocols),
loggerFactory.CreateLogger <RabbitMQBus>(),
_serverName);
_ = EnsureRabbitMQServerConnection();
}
public CourseStudentRepository(ILogger logger
, IGenericsDbContextRepository <Models.CourseStudent> courseStudentDbContext
, IGenericsDbContextRepository <Models.Course> courseDbContext
, IMessageSystem messageSystem
, RabbitMQBus messagingServiceBus)
{
_logger = logger;
_messagingServiceBus = messagingServiceBus;
_courseStudentDbContext = courseStudentDbContext;
_courseDbContext = courseDbContext;
_messageSystem = messageSystem;
}
public void Setup()
{
bus1 = new RabbitMQBus(Environment.GetEnvironmentVariable("RUNZ_TEST_RABBITMQ_SERVER") ?? "localhost");
bus2 = new RabbitMQBus(Environment.GetEnvironmentVariable("RUNZ_TEST_RABBITMQ_SERVER") ?? "localhost");
bus1.PurgeQueue(unitTest0);
bus1.PurgeQueue(unitTest1);
bus1.PurgeQueue(unitTest2);
bus1.PurgeQueue(unitTest3);
bus1.PurgeQueue(unitTest4);
bus1.PurgeQueue(unitTest5);
bus1.PurgeQueue(unitTest7);
}
public Worker(ILogger <Worker> logger, IConfiguration configuration, WordsGrpcService words)
{
words.Init();
_logger = logger;
var busServer = configuration["RabbitServer"];
var gameConsumerBus = new RabbitMQBus(busServer, "game", "game-ex");
var rtmPublisherBus = new RabbitMQBus(busServer, "rtm", "rtm-ex");
Worker.GamesManager = new GamesManager(gameConsumerBus, rtmPublisherBus, words);
}
public void MessageWithInternalHierarchy_DataSerialized()
{
ManualResetEvent ev = new ManualResetEvent(false);
using (IBus busA = new RabbitMQBus(), busB = new RabbitMQBus())
{
var data = new InternalHierarchy
{
Data = new List<Data>
{
new Car
{
Number = "324234"
},
new Person
{
Id = 5
}
}
};
InternalHierarchy actual = null;
using (ISubscriber subscriber = busA.CreateSubscriber(c => c.UseJsonSerializerSettings(new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All
})))
{
subscriber.Subscribe((Action<InternalHierarchy>)(p =>
{
actual = p;
ev.Set();
}));
subscriber.Open();
using (IPublisher publisher = busB.CreatePublisher(c => c.UseJsonSerializerSettings(new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All
})))
{
publisher.Send(data);
}
ev.WaitOne(TimeSpan.FromSeconds(5));
actual.ShouldBeEquivalentTo(data);
}
}
}
public void MessageWithInternalHierarchy_DataSerialized()
{
ManualResetEvent ev = new ManualResetEvent(false);
using (IBus busA = new RabbitMQBus(), busB = new RabbitMQBus())
{
var data = new InternalHierarchy
{
Data = new List <Data>
{
new Car
{
Number = "324234"
},
new Person
{
Id = 5
}
}
};
InternalHierarchy actual = null;
using (ISubscriber subscriber = busA.CreateSubscriber(c => c.UseJsonSerializerSettings(new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All
})))
{
subscriber.Subscribe((Action <InternalHierarchy>)(p =>
{
actual = p;
ev.Set();
}));
subscriber.Open();
using (IPublisher publisher = busB.CreatePublisher(c => c.UseJsonSerializerSettings(new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All
})))
{
publisher.Send(data);
}
ev.WaitOne(TimeSpan.FromSeconds(5));
actual.ShouldBeEquivalentTo(data);
}
}
}
public void Bus_PublishRawMessages_MonitorReceiveNotFiltered()
{
ManualResetEvent ev = new ManualResetEvent(false);
using (IBus bus = new RabbitMQBus())
{
List <SerializedBusMessage> actual = new List <SerializedBusMessage>();
SerializedBusMessage toFilterOut = new SerializedBusMessage
{
Name = "SomeOtherName",
Namespace = "",
Data = new byte[] { 0, 2, 31, 11, 22 },
ContentType = "binary"
};
SerializedBusMessage expected = new SerializedBusMessage
{
Name = "MyName",
Namespace = "",
Data = new byte[] { 1, 7, 11, 71 },
ContentType = "binary"
};
Action <SerializedBusMessage> action = message =>
{
actual.Add(message);
};
using (ISubscription monitor = bus.CreateMonitor(action, filterHeaders: new [] { new BusHeader("Name", "MyName") }))
{
monitor.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(toFilterOut);
publisher.Send(expected);
}
ev.WaitOne(TimeSpan.FromSeconds(10));
actual.Count.Should().Be(1);
actual[0].Name.Should().Be("MyName");
actual[0].Namespace.Should().Be("");
Assert.AreEqual(actual[0].Data, expected.Data);
}
}
}
public void Start()
{
Bus = RabbitMQBus.Load(ConfigDirectory + "Bus.config");
Bus.Start();
Sender = RabbitMQSender <RabbitMQMultiStringKeyValuePairsMessageModel> .Load(ConfigDirectory + "Sender.config");
Sender.BindBus(Bus);
Sender.Start();
Receiver = RabbitMQReceiver <RabbitMQMultiStringKeyValuePairsMessageModel> .Load(ConfigDirectory + "Receiver.config");
Receiver.BindBus(Bus);
Receiver.Start();
}
public void WaitForConfirm_ConfirmShouldArrive()
{
using (IBus bus = new RabbitMQBus())
{
using (IConfirmPublisher publisher = bus.CreateConfirmPublisher())
{
publisher.Send(new Person
{
Id = 5
});
var waitForConfirms = publisher.WaitForConfirms(TimeSpan.FromSeconds(10));
Assert.IsTrue(waitForConfirms);
}
}
}
public void WaitForConfirm_ConfirmShouldArrive()
{
using (IBus bus = new RabbitMQBus())
{
using (IConfirmPublisher publisher = bus.CreateConfirmPublisher())
{
publisher.Send(new Person
{
Id = 5
});
var waitForConfirms = publisher.WaitForConfirms(TimeSpan.FromSeconds(10));
Assert.IsTrue(waitForConfirms);
}
}
}
public void Bus_MakeAsyncRpcCall()
{
using (IBus bus = new RabbitMQBus(c => c.SetReceiveSelfPublish()))
{
using (ISubscriber subscriber = bus.CreateSubscriber())
{
subscriber.Subscribe((RequestMessage m) => new ResponseMessage
{
Code = m.Data.Length
});
subscriber.Open();
using (IRpcAsyncPublisher rpcPublisher = bus.CreateAsyncRpcPublisher())
{
ResponseMessage response = null;
using (ManualResetEvent ev = new ManualResetEvent(false))
{
rpcPublisher.Send<RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "Hello, world!"
}, TimeSpan.FromSeconds(10)).ContinueWith(t =>
{
response = t.Result;
ev.Set();
});
bool waitOne = ev.WaitOne(TimeSpan.FromSeconds(20));
if (!waitOne)
{
Assert.Fail("No response received");
}
response.ShouldBeEquivalentTo(new ResponseMessage
{
Code = 13
});
}
}
}
}
}
public void Bus_MakeAsyncRpcCall()
{
using (IBus bus = new RabbitMQBus(c => c.SetReceiveSelfPublish()))
{
using (ISubscriber subscriber = bus.CreateSubscriber())
{
subscriber.Subscribe((RequestMessage m) => new ResponseMessage
{
Code = m.Data.Length
});
subscriber.Open();
using (IRpcAsyncPublisher rpcPublisher = bus.CreateAsyncRpcPublisher())
{
ResponseMessage response = null;
using (ManualResetEvent ev = new ManualResetEvent(false))
{
rpcPublisher.Send <RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "Hello, world!"
}, TimeSpan.FromSeconds(10)).ContinueWith(t =>
{
response = t.Result;
ev.Set();
});
bool waitOne = ev.WaitOne(TimeSpan.FromSeconds(20));
if (!waitOne)
{
Assert.Fail("No response received");
}
response.ShouldBeEquivalentTo(new ResponseMessage
{
Code = 13
});
}
}
}
}
}
public void UseCustomFormat_MessageSent_Received()
{
ManualResetEvent ev = new ManualResetEvent(false);
using (IBus busA = new RabbitMQBus(), busB = new RabbitMQBus())
{
Person person = new Person
{
Id = 5
};
Person actual = null;
ISerializer serializer = A.Fake<ISerializer>();
A.CallTo(() => serializer.Serialize(A<RawBusMessage>._)).Returns(new byte[0]);
A.CallTo(() => serializer.Deserialize(new DataContractKey(typeof(Person).Name, typeof(Person).Namespace), typeof(Person), A<byte[]>._)).Returns(person);
A.CallTo(() => serializer.ContentType).Returns("Custom");
using (ISubscriber subscriber = busA.CreateSubscriber(c => c.AddCustomSerializer(serializer)))
{
subscriber.Subscribe((Action<Person>) (p =>
{
actual = p;
ev.Set();
}));
subscriber.Open();
using (IPublisher publisher = busB.CreatePublisher(c => c.UseCustomSerializer(serializer)))
{
publisher.Send(new Person());
}
ev.WaitOne(TimeSpan.FromSeconds(5));
actual.ShouldBeEquivalentTo(person);
}
A.CallTo(() => serializer.Serialize(A<RawBusMessage>._)).MustHaveHappened();
A.CallTo(() => serializer.Deserialize(new DataContractKey(typeof(Person).Name, typeof(Person).Namespace), typeof(Person), A<byte[]>._)).MustHaveHappened();
}
}
public void UseCustomFormat_MessageSent_Received()
{
ManualResetEvent ev = new ManualResetEvent(false);
using (IBus busA = new RabbitMQBus(), busB = new RabbitMQBus())
{
Person person = new Person
{
Id = 5
};
Person actual = null;
ISerializer serializer = A.Fake <ISerializer>();
A.CallTo(() => serializer.Serialize(A <RawBusMessage> ._)).Returns(new byte[0]);
A.CallTo(() => serializer.Deserialize(typeof(Person), A <byte[]> ._)).Returns(person);
A.CallTo(() => serializer.ContentType).Returns("Custom");
using (ISubscriber subscriber = busA.CreateSubscriber(c => c.AddCustomSerializer(serializer)))
{
subscriber.Subscribe((Action <Person>)(p =>
{
actual = p;
ev.Set();
}));
subscriber.Open();
using (IPublisher publisher = busB.CreatePublisher(c => c.UseCustomSerializer(serializer)))
{
publisher.Send(new Person());
}
ev.WaitOne(TimeSpan.FromSeconds(5));
actual.ShouldBeEquivalentTo(person);
}
A.CallTo(() => serializer.Serialize(A <RawBusMessage> ._)).MustHaveHappened();
A.CallTo(() => serializer.Deserialize(typeof(Person), A <byte[]> ._)).MustHaveHappened();
}
}
public void Bus_SendReceive_BunchOfMessages()
{
//RabbitMQConnectionString connectionString = new RabbitMQConnectionString(new Uri("amqp://*****:*****@10.0.8.100"));
using (RabbitMQBus entityA = new RabbitMQBus(), entityB = new RabbitMQBus())
{
Data messageA = new Person
{
Id = 5
};
ManualResetEvent ev1 = new ManualResetEvent(false);
int counter = 0;
using (ISubscriber subscriberA = entityA.CreateSubscriber())
{
subscriberA.Subscribe((Action<Data>)(d => Counter(ref counter)), true);
subscriberA.Subscribe(typeof(OK), (Action<object>)(data => ev1.Set()));
subscriberA.Open();
const int expected = 100000;
using (IPublisher publisher = entityB.CreatePublisher())
{
for (int i = 0; i < expected; i++)
{
publisher.Send(messageA);
}
publisher.Send(new OK());
}
bool waitOne = ev1.WaitOne(TimeSpan.FromSeconds(20));
waitOne.Should().BeTrue("Message not received");
counter.Should().Be(expected);
}
}
}
public void Send_Receive_CustomSerializationMessage()
{
using (IBus bus = new RabbitMQBus())
{
using (IChannelFactory <ITestContract> channelFactory = new MessageBus.Core.Proxy.ChannelFactory <ITestContract>(bus, c => c.UseJsonSerializerSettings(new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto
})))
{
ISubscriptionFactory <ITestContract> subscriptionFactory = new SubscriptionFactory <ITestContract>(bus);
Data actual = null;
ManualResetEvent ev = new ManualResetEvent(false);
Data data = new Data
{
Value = "boo"
};
using (ISubscriptionSelector <ITestContract> selector = subscriptionFactory.Subscribe(c => c.SetReceiveSelfPublish().UseJsonSerializerSettings(new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto
})))
{
selector.Subscribe <Data>(contract => contract.Foo, s =>
{
actual = s;
ev.Set();
});
ITestContract channel = channelFactory.CreateChannel();
channel.Foo(data);
ev.WaitOne(TimeSpan.FromSeconds(5));
actual.ShouldBeEquivalentTo(data);
}
}
}
}
public void Initialize()
{
using (var bus = new RabbitMQBus())
{
using (IRouteManager routeManager = bus.CreateRouteManager())
{
routeManager.CreateQueue(QueueName, true, false, new CreateQueueSettings
{
DeadLetterExchange = "amq.direct",
DeadLetterRoutingKey = "fail"
});
routeManager.CreateQueue(DeadLetterQueueName, true, false, CreateQueueSettings.Default);
routeManager.QueueBindMessage <TransactionalPerson>(QueueName);
routeManager.QueueBindMessage <TransactionalPerson>(DeadLetterQueueName, "amq.direct", "fail");
}
}
}
public void Bus_SendReceive_BunchOfMessages()
{
//RabbitMQConnectionString connectionString = new RabbitMQConnectionString(new Uri("amqp://*****:*****@10.0.8.100"));
using (RabbitMQBus entityA = new RabbitMQBus(), entityB = new RabbitMQBus())
{
Data messageA = new Person
{
Id = 5
};
ManualResetEvent ev1 = new ManualResetEvent(false);
int counter = 0;
using (ISubscriber subscriberA = entityA.CreateSubscriber())
{
subscriberA.Subscribe((Action <Data>)(d => Counter(ref counter)), true);
subscriberA.Subscribe(typeof(OK), (Action <object>)(data => ev1.Set()));
subscriberA.Open();
const int expected = 1000;
using (IPublisher publisher = entityB.CreatePublisher())
{
for (int i = 0; i < expected; i++)
{
publisher.Send(messageA);
}
publisher.Send(new OK());
}
bool waitOne = ev1.WaitOne(TimeSpan.FromSeconds(20));
waitOne.Should().BeTrue("Message not received");
counter.Should().Be(expected);
}
}
}
public void Bus_MessageBaseSubscribtion_CallReceived()
{
ManualResetEvent ev = new ManualResetEvent(false);
MessageBasedImplementation implementation = new MessageBasedImplementation(ev);
using (IBus bus = new RabbitMQBus())
{
using (ISubscription subscription = bus.RegisterSubscription(implementation))
{
subscription.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
Person person = new Person {
Id = 5
};
BusMessage <Person> busMessage = new BusMessage <Person>
{
Data = person
};
busMessage.Headers.Add(new BusHeader
{
Name = "Header",
Value = "RightValue"
});
publisher.Send(busMessage);
bool waitOne = ev.WaitOne(TimeSpan.FromSeconds(5));
waitOne.Should().BeTrue();
busMessage.ShouldBeEquivalentTo(implementation.Message,
options =>
options.Excluding(message => message.BusId)
.Excluding(message => message.Sent));
}
}
}
}
public void Initialize()
{
using (var bus = new RabbitMQBus())
{
using (IRouteManager routeManager = bus.CreateRouteManager())
{
routeManager.CreateQueue(QueueName, true, false, new CreateQueueSettings
{
DeadLetterExchange = "amq.direct",
DeadLetterRoutingKey = "fail"
});
routeManager.CreateQueue(DeadLetterQueueName, true, false, CreateQueueSettings.Default);
routeManager.QueueBindMessage<Person>(QueueName);
routeManager.QueueBindMessage<Person>(DeadLetterQueueName, "amq.direct", "fail");
}
}
}
public void Send_Receive_CustomSerializationMessage()
{
using (IBus bus = new RabbitMQBus())
{
using (IChannelFactory<ITestContract> channelFactory = new MessageBus.Core.Proxy.ChannelFactory<ITestContract>(bus, c => c.UseJsonSerializerSettings(new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto
})))
{
ISubscriptionFactory<ITestContract> subscriptionFactory = new SubscriptionFactory<ITestContract>(bus);
Data actual = null;
ManualResetEvent ev = new ManualResetEvent(false);
Data data = new Data
{
Value = "boo"
};
using (ISubscriptionSelector<ITestContract> selector = subscriptionFactory.Subscribe(c => c.SetReceiveSelfPublish().UseJsonSerializerSettings(new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto
})))
{
selector.Subscribe<Data>(contract => contract.Foo, s =>
{
actual = s;
ev.Set();
});
ITestContract channel = channelFactory.CreateChannel();
channel.Foo(data);
ev.WaitOne(TimeSpan.FromSeconds(5));
actual.ShouldBeEquivalentTo(data);
}
}
}
}
public void Bus_MessageBaseSubscribtion_CallReceived()
{
ManualResetEvent ev = new ManualResetEvent(false);
MessageBasedImplementation implementation = new MessageBasedImplementation(ev);
using (IBus bus = new RabbitMQBus())
{
using (ISubscription subscription = bus.RegisterSubscription(implementation))
{
subscription.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
Person person = new Person {Id = 5};
BusMessage<Person> busMessage = new BusMessage<Person>
{
Data = person
};
busMessage.Headers.Add(new BusHeader
{
Name = "Header",
Value = "RightValue"
});
publisher.Send(busMessage);
bool waitOne = ev.WaitOne(TimeSpan.FromSeconds(5));
waitOne.Should().BeTrue();
busMessage.ShouldBeEquivalentTo(implementation.Message,
options =>
options.Excluding(message => message.BusId)
.Excluding(message => message.Sent));
}
}
}
}
public void MessageProcessFailedOnce_CheckMessageRedelivered()
{
using (RabbitMQBus entityA = new RabbitMQBus(), entityB = new RabbitMQBus())
{
Person message = new Person
{
Id = 5
};
ManualResetEvent ev = new ManualResetEvent(false);
int counter = 0;
using (ISubscriber subscriberA = entityA.CreateSubscriber(c => c.UseTransactionalDelivery()))
{
subscriberA.Subscribe((Action<Person>)(d =>
{
counter++;
if (counter == 1)
{
throw new Exception();
}
}));
subscriberA.Open();
const int expected = 2;
using (IPublisher publisher = entityB.CreatePublisher())
{
publisher.Send(message);
}
ev.WaitOne(TimeSpan.FromSeconds(5));
counter.Should().Be(expected);
}
}
}
public void SendAndReciveMessageFromFanoutExchangeWithRoutingKey()
{
using (IBus busA = new RabbitMQBus(), busB = new RabbitMQBus())
{
Person expected = new Person
{
Id = 5
};
Person actual = null;
ManualResetEvent ev = new ManualResetEvent(false);
using (var subscriber = busB.CreateSubscriber(c => c.SetExchange("amq.fanout").SetRoutingKey("MyKey")))
{
subscriber.Subscribe((Person p) =>
{
actual = p;
ev.Set();
});
subscriber.Open();
using (var publisher = busA.CreatePublisher(c => c.SetExchange("amq.fanout").SetRoutingKey("MyKey")))
{
publisher.Send(expected);
}
bool waitOne = ev.WaitOne(TimeSpan.FromSeconds(20));
waitOne.Should().BeTrue("Message not received");
actual.ShouldBeEquivalentTo(expected);
}
}
}
public void UseSoapFormat_MessageSent_Received()
{
ManualResetEvent ev = new ManualResetEvent(false);
using (IBus busA = new RabbitMQBus(), busB = new RabbitMQBus())
{
Person person = new Person
{
Id = 5
};
Person actual = null;
using (ISubscriber subscriber = busA.CreateSubscriber())
{
subscriber.Subscribe((Action<Person>) (p =>
{
actual = p;
ev.Set();
}));
subscriber.Open();
using (IPublisher publisher = busB.CreatePublisher(c => c.UseSoapSerializer()))
{
publisher.Send(person);
}
ev.WaitOne(TimeSpan.FromSeconds(5));
actual.ShouldBeEquivalentTo(person);
}
}
}
public void Bus_SubscribtionWithFilter_CallFiltered()
{
ManualResetEvent ev = new ManualResetEvent(false);
FilterImplementation implementation = new FilterImplementation(ev);
using (IBus bus = new RabbitMQBus())
{
using (ISubscription subscription = bus.RegisterSubscription(implementation))
{
subscription.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
Person person = new Person {Id = 5};
BusMessage<Person> busMessage = new BusMessage<Person>
{
Data = person
};
busMessage.Headers.Add(new BusHeader
{
Name = "Header",
Value = "WrongValue"
});
publisher.Send(busMessage);
bool waitOne = ev.WaitOne(TimeSpan.FromSeconds(5));
waitOne.Should().BeFalse();
}
}
}
}
public async void Bus_MakeRpcCall_NotRoutedToAnySubscriber()
{
using (IBus bus = new RabbitMQBus(c => c.SetReceiveSelfPublish()))
{
using (IRpcAsyncPublisher rpcPublisher = bus.CreateAsyncRpcPublisher())
{
try
{
await rpcPublisher.Send<RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "Hello, world!"
}, TimeSpan.FromSeconds(10));
Assert.Fail("No exception");
}
catch (RpcCallException ex)
{
ex.Reason.Should().Be(RpcFailureReason.NotRouted);
}
}
}
}
public async void Bus_MakeRpcCall_TimeOutOnReply()
{
using (IBus bus = new RabbitMQBus(c => c.SetReceiveSelfPublish()))
{
using (ISubscriber subscriber = bus.CreateSubscriber())
{
subscriber.Subscribe((RequestMessage m) => Thread.Sleep(TimeSpan.FromSeconds(20)));
subscriber.Open();
using (IRpcAsyncPublisher rpcPublisher = bus.CreateAsyncRpcPublisher())
{
try
{
await rpcPublisher.Send<RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "Hello, world!"
}, TimeSpan.FromSeconds(10));
Assert.Fail("No exception");
}
catch (RpcCallException ex)
{
ex.Reason.Should().Be(RpcFailureReason.TimeOut);
}
}
}
}
}
public async void Bus_MakeRpcCall_RejectedByHandler()
{
using (IBus bus = new RabbitMQBus(c => c.SetReceiveSelfPublish()))
{
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.UseTransactionalDelivery()))
{
subscriber.Subscribe((RequestMessage m) =>
{
throw new RejectMessageException();
});
subscriber.Open();
using (IRpcAsyncPublisher rpcPublisher = bus.CreateAsyncRpcPublisher())
{
try
{
await rpcPublisher.Send<RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "Hello, world!"
}, TimeSpan.FromSeconds(10));
Assert.Fail("No exception");
}
catch (RpcCallException ex)
{
ex.Reason.Should().Be(RpcFailureReason.Reject);
}
}
}
}
}
public void MessageProcessFailedOnce_RejectMessage_CheckMessageDeliveredToDeadLetterQ()
{
using (RabbitMQBus entityA = new RabbitMQBus(), entityB = new RabbitMQBus(), entityC = new RabbitMQBus(c => c.UseConnectionString("amqp://localhost/amq.direct")))
{
Person message = new Person
{
Id = 5
};
ManualResetEvent ev = new ManualResetEvent(false);
int counter = 0;
BusMessage<Person> actual = null;
using (ISubscriber subscriberA = entityA.CreateSubscriber(c => c.UseDurableQueue(QueueName).UseTransactionalDelivery()))
{
subscriberA.Subscribe((Action<Person>) (d =>
{
counter++;
if (counter == 1)
{
throw new Exception();
}
throw new RejectMessageException();
}));
subscriberA.Open();
using (ISubscriber deadLetterSubscriber = entityC.CreateSubscriber(c => c.UseDurableQueue(DeadLetterQueueName)))
{
deadLetterSubscriber.Subscribe<Person>(m =>
{
actual = m;
ev.Set();
});
deadLetterSubscriber.Open();
const int expected = 2;
using (IPublisher publisher = entityB.CreatePublisher())
{
publisher.Send(message);
}
bool waitOne = ev.WaitOne(TimeSpan.FromSeconds(50));
counter.Should().BeGreaterOrEqualTo(expected);
waitOne.Should().BeTrue();
actual.Data.ShouldBeEquivalentTo(message);
XDeadHeader xDeadHeader = actual.Headers.OfType<XDeadHeader>().First();
xDeadHeader.Exchange.Should().Be("amq.headers");
xDeadHeader.Reason.Should().Be("rejected");
xDeadHeader.Queue.Should().Be(QueueName);
}
}
}
}
public void Bus_MultiClientRpcCall()
{
using (IBus serviceBus = new RabbitMQBus(), client1Bus = new RabbitMQBus(), client2Bus = new RabbitMQBus())
{
using (ISubscriber subscriber = serviceBus.CreateSubscriber())
{
subscriber.Subscribe((RequestMessage m) => new ResponseMessage
{
Code = int.Parse(m.Data)
});
subscriber.Open();
const int calls = 20;
using (IRpcPublisher rpcPublisher1 = client1Bus.CreateRpcPublisher(), rpcPublisher2 = client2Bus.CreateRpcPublisher())
{
List<ResponseMessage> c1Responses = new List<ResponseMessage>(), c2Responses = new List<ResponseMessage>();
Task t1 = Task.Factory.StartNew(() =>
{
for (int i = 0; i < calls; i++)
{
ResponseMessage response =
rpcPublisher1.Send<RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "1"
}, TimeSpan.FromSeconds(10));
c1Responses.Add(response);
}
});
Task t2 = Task.Factory.StartNew(() =>
{
for (int i = 0; i < calls; i++)
{
ResponseMessage response =
rpcPublisher2.Send<RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "2"
}, TimeSpan.FromSeconds(10));
c2Responses.Add(response);
}
});
Task.WaitAll(t1, t2);
c1Responses.Should().HaveCount(calls);
c2Responses.Should().HaveCount(calls);
c1Responses.All(message => message.Code == 1).Should().BeTrue();
c2Responses.All(message => message.Code == 2).Should().BeTrue();
}
}
}
}
public void Bus_MakeSyncRpcCall_NoFastReply_CustomExchange_NoReplyTo()
{
using (IBus bus = new RabbitMQBus(c => c.SetReceiveSelfPublish()))
{
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.SetReplyExchange("amq.direct")))
{
subscriber.Subscribe((RequestMessage m) => new ResponseMessage
{
Code = m.Data.Length
});
subscriber.Open();
using (IRpcPublisher rpcPublisher = bus.CreateRpcPublisher(c => c.DisableFastReply().SetReplyExchange("amq.direct")))
{
ResponseMessage response = rpcPublisher.Send<RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "Hello, world!"
}, TimeSpan.FromSeconds(10));
response.ShouldBeEquivalentTo(new ResponseMessage
{
Code = 13
});
}
}
}
}
public void Bus_MultiClientRpcCall()
{
using (IBus serviceBus = new RabbitMQBus(), client1Bus = new RabbitMQBus(), client2Bus = new RabbitMQBus())
{
using (ISubscriber subscriber = serviceBus.CreateSubscriber())
{
subscriber.Subscribe((RequestMessage m) => new ResponseMessage
{
Code = int.Parse(m.Data)
});
subscriber.Open();
using (IRpcAsyncPublisher rpcPublisher1 = client1Bus.CreateAsyncRpcPublisher(), rpcPublisher2 = client2Bus.CreateAsyncRpcPublisher())
{
List<ResponseMessage> c1Responses = new List<ResponseMessage>(), c2Responses = new List<ResponseMessage>();
Task t1 = rpcPublisher1.Send<RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "1"
}, TimeSpan.FromSeconds(10)).ContinueWith(task => c1Responses.Add(task.Result));
Task t2 = rpcPublisher2.Send<RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "2"
}, TimeSpan.FromSeconds(10)).ContinueWith(task => c2Responses.Add(task.Result));
Task.WaitAll(t1, t2);
c1Responses.All(message => message.Code == 1).Should().BeTrue();
c2Responses.All(message => message.Code == 2).Should().BeTrue();
}
}
}
}
public void Setup()
{
theBus = new RabbitMQBus(OSHelpers.RabbitHost());
}
public void Setup()
{
bus = new RabbitMQBus(Environment.GetEnvironmentVariable("RUNZ_TEST_RABBITMQ_SERVER") ?? "localhost");
}
public void Bus_MakeRpcCall_RejectedWithDataByHandler()
{
ResponseMessage replyData = new ResponseMessage
{
Code = 234
};
using (IBus bus = new RabbitMQBus(c => c.SetReceiveSelfPublish()))
{
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.UseTransactionalDelivery()))
{
subscriber.Subscribe((RequestMessage m) => {
throw new RejectMessageException
{
ReplyData = replyData
};
});
subscriber.Open();
using (IRpcPublisher rpcPublisher = bus.CreateRpcPublisher())
{
try
{
rpcPublisher.Send<RequestMessage, ResponseMessage>(new RequestMessage
{
Data = "Hello, world!"
}, TimeSpan.FromSeconds(10));
Assert.Fail("No exception");
}
catch (RpcCallException ex)
{
ex.Reason.Should().Be(RpcFailureReason.Reject);
ex.ReplyData.Should().BeOfType<ResponseMessage>();
((ResponseMessage)ex.ReplyData).ShouldBeEquivalentTo(replyData);
}
}
}
}
}
public async void Bus_MakeRpcVoidCall_SubscriberReturnData()
{
using (IBus bus = new RabbitMQBus(c => c.SetReceiveSelfPublish()))
{
using (ISubscriber subscriber = bus.CreateSubscriber())
{
RequestMessage actual = null;
subscriber.Subscribe((RequestMessage m) =>
{
actual = m;
return new ResponseMessage();
});
subscriber.Open();
using (IRpcAsyncPublisher rpcPublisher = bus.CreateAsyncRpcPublisher())
{
var expected = new RequestMessage
{
Data = "Hello, world!"
};
await rpcPublisher.Send(expected, TimeSpan.FromSeconds(10));
actual.ShouldBeEquivalentTo(expected);
}
}
}
}
