public void CanSendMessageToMultipleSubscribers()
{
var latch = new CountDownLatch(3);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Publish(new SimpleMessageA {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
public void CanSubscribeToAllMessageTypes()
{
var latch = new CountDownLatch(3);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe <object>(msg => {
latch.Signal();
});
messageBus.Publish(new SimpleMessageA {
Data = "Hello"
});
messageBus.Publish(new SimpleMessageB {
Data = "Hello"
});
messageBus.Publish(new SimpleMessageC {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
public void CanSendMessage() {
var resetEvent = new AutoResetEvent(false);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
resetEvent.Set();
});
messageBus.Publish(new SimpleMessageA {
Data = "Hello"
});
bool success = resetEvent.WaitOne(100);
Assert.True(success, "Failed to receive message.");
}
public void WillReceiveDerivedMessageTypes()
{
var latch = new CountDownLatch(2);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe <ISimpleMessage>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Publish(new SimpleMessageA {
Data = "Hello"
});
messageBus.Publish(new SimpleMessageB {
Data = "Hello"
});
messageBus.Publish(new SimpleMessageC {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
public ActionResult Post([FromBody] PurchaseOrder order)
{
if (_context.PurchaseOrders.Any(x => x.Id == order.Id))
{
return(StatusCode(409));
}
_context.PurchaseOrders.Add(order);
_context.SaveChanges();
//this should come from the domain and the event should only contain primitive types in order to simplify versioning
_bus.Publish(new PurchaseOrderReceived(Guid.NewGuid(), Guid.NewGuid(), order.Id, order.BooksOrdered));
return(Accepted($"{Request.Path.ToUriComponent()}/{order.Id}", order));
}
public void CanSendMessage()
{
var resetEvent = new AutoResetEvent(false);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
resetEvent.Set();
});
messageBus.Publish(new SimpleMessageA {
Data = "Hello"
});
bool success = resetEvent.WaitOne(100);
Assert.True(success, "Failed to receive message.");
}
public void Handle(PurchaseOrderReceived @event)
{
// Invoke the shipping domain to check stock for every book using this service's own db
// calculate shipping cost based on destination
// if all is OK, store the shipping manifest and publish an event
var totalCostWithoutShipping = @event.BooksOrdered.Sum(x => x.BookPrice);
var shippingCost = totalCostWithoutShipping * 0.2m;
var shippingManifest = new ShippingManifest
{
BookIds = String.Join(", ", @event.BooksOrdered.Select(x => x.Id).ToList()),
ShippingCost = shippingCost,
ShippingReference = $"SP{@event.Id}"
};
_context.ShippingManifests.Add(shippingManifest);
_context.SaveChanges();
_bus.Publish(new OrderShipped(Guid.NewGuid(), @event.CorrelationId, shippingManifest.ShippingReference,
@event.BooksOrdered.Select(x => x.Id).ToList(), shippingCost, totalCostWithoutShipping + shippingCost));
}
public void CanTolerateSubscriberFailure() {
var latch = new CountDownLatch(2);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<SimpleMessageA>(msg => {
throw new ApplicationException();
});
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Publish(new SimpleMessageA {
Data = "Hello"
});
bool success = latch.Wait(900);
Assert.True(success, "Failed to receive all messages.");
}
public void CanSendMessageToMultipleSubscribers() {
var latch = new CountDownLatch(3);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Publish(new SimpleMessageA {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
public void CanTolerateSubscriberFailure()
{
var latch = new CountDownLatch(2);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe <SimpleMessageA>(msg => {
throw new ApplicationException();
});
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Publish(new SimpleMessageA {
Data = "Hello"
});
bool success = latch.Wait(900);
Assert.True(success, "Failed to receive all messages.");
}
public void CanSendDelayedMessage()
{
var resetEvent = new AutoResetEvent(false);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
resetEvent.Set();
});
var sw = new Stopwatch();
messageBus.Publish(new SimpleMessageA {
Data = "Hello"
}, TimeSpan.FromMilliseconds(100));
sw.Start();
bool success = resetEvent.WaitOne(1200);
sw.Stop();
Assert.True(success, "Failed to receive message.");
Assert.True(sw.Elapsed > TimeSpan.FromMilliseconds(100));
}
public void WillReceiveDerivedMessageTypes() {
var latch = new CountDownLatch(2);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<ISimpleMessage>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Publish(new SimpleMessageA {
Data = "Hello"
});
messageBus.Publish(new SimpleMessageB {
Data = "Hello"
});
messageBus.Publish(new SimpleMessageC {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
public void CanSubscribeToAllMessageTypes() {
var latch = new CountDownLatch(3);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<object>(msg => {
latch.Signal();
});
messageBus.Publish(new SimpleMessageA {
Data = "Hello"
});
messageBus.Publish(new SimpleMessageB {
Data = "Hello"
});
messageBus.Publish(new SimpleMessageC {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}