static void Main(string[] args)
{
//add event subscriptions
EventSubscriptions.Add<EmailOrderConfirmation>();
EventSubscriptions.Add<NotifyWarehouse>();
EventSubscriptions.Add<DeductOnHandInventory>();
//publish
IEventPublisher eventPublisher = new EventPublisher(new EventSubscriptions());
eventPublisher.PublishAsync<OrderSubmittedEvent>(new OrderSubmittedEvent { OrderId = Guid.NewGuid().ToString() });
eventPublisher.PublishAsync<OrderSubmittedEvent>(new OrderSubmittedEvent { OrderId = Guid.NewGuid().ToString() });
//Console.ReadKey();
}
public void PublishAsyncWithRawDataCallsSendMessageWithExpectedMessage(long timestamp, string topic, string eventType, string body)
{
// Arrange
Mock <IBusContext <IConnection> > contextMock = new Mock <IBusContext <IConnection> >();
Mock <IMessageSender> senderMock = new Mock <IMessageSender>();
contextMock.Setup(e => e.CreateMessageSender())
.Returns(senderMock.Object);
EventMessage result = new EventMessage();
senderMock.Setup(e => e.SendMessage(It.IsAny <EventMessage>()))
.Callback <EventMessage>(e => result = e);
EventPublisher publisher = new EventPublisher(contextMock.Object);
Guid calculatedGuid = Guid.NewGuid();
// Act
publisher.PublishAsync(timestamp, topic, calculatedGuid, eventType, body);
Thread.Sleep(AsyncWaitTime);
// Assert
Assert.AreEqual(timestamp, result.Timestamp);
Assert.AreEqual(topic, result.Topic);
Assert.AreEqual(eventType, result.EventType);
Assert.AreEqual(body, Encoding.Unicode.GetString(result.Body));
Assert.AreEqual(calculatedGuid, result.CorrelationId);
}
public Task Should_Throw_If_Cancellation_Token_Source_Is_Cancelled()
{
return(Assert.ThrowsAnyAsync <OperationCanceledException>(async() =>
{
var asyncHandler1 = new TestEventAsyncHandler1(_testOutputHelper);
var registration = new EventHandlerRegistration();
registration.Register <TriggerLongRunningEvent>(() => asyncHandler1);
var publisher = new EventPublisher(registration);
publisher.OnError += (@event, ex) =>
{
_testOutputHelper.WriteLine(ex.Message);
};
var cts = new CancellationTokenSource();
Task publishTask = publisher.PublishAsync(new TriggerLongRunningEvent(1000), cts.Token);
cts.Cancel();
try
{
await publishTask;
}
catch (Exception ex)
{
_testOutputHelper.WriteLine(ex.Message);
throw;
}
}));
}
public async Task Events_should_be_published_on_correct_order()
{
var ids = new List <Tuple <Guid, int> >();
var handler1 = new OrderTestEventHandler(ids);
var handlers = new List <Action <OrderedTestEvent> >
{
evt => handler1.ExecuteAsync(evt)
};
var eventRouter = CreateEventRouter(handlers);
EventPublisher eventPublisher = new EventPublisher(eventRouter);
var orderTestEvent = new OrderedTestEvent(Guid.NewGuid(), 1);
var orderTestEvent2 = new OrderedTestEvent(Guid.NewGuid(), 2);
var orderTestEvent3 = new OrderedTestEvent(Guid.NewGuid(), 3);
await eventPublisher.PublishAsync <IDomainEvent>(new[]
{
orderTestEvent,
orderTestEvent2,
orderTestEvent3
}).ConfigureAwait(false);
await eventPublisher.CommitAsync().ConfigureAwait(false);
ids[0].Item2.Should().Be(orderTestEvent.Order);
ids[1].Item2.Should().Be(orderTestEvent2.Order);
ids[2].Item2.Should().Be(orderTestEvent3.Order);
}
public async Task Should_Invoke_All_Registered_Event_Handlers_In_Registration()
{
var asyncHandler1 = new TestEventAsyncHandler1(_testOutputHelper);
var asyncHandler2 = new TestEventAsyncHandler2(_testOutputHelper);
var asyncHandler3 = new TestEventAsyncHandler3(_testOutputHelper);
var handler1 = new TestEventHandler1(_testOutputHelper);
var handler2 = new TestEventHandler2(_testOutputHelper);
var handler3 = new TestEventHandler3(_testOutputHelper);
var registration = new EventHandlerRegistration();
registration.Register <TestEvent1>(() => handler1);
registration.Register <TestEvent1>(() => handler2);
registration.Register <TestEvent1>(() => handler3);
registration.Register <TestEvent1>(() => asyncHandler1);
registration.Register <TestEvent1>(() => asyncHandler2);
registration.Register <TestEvent1>(() => asyncHandler3);
var publisher = new EventPublisher(registration);
publisher.OnError += (@event, ex) =>
{
_testOutputHelper.WriteLine(ex.Message);
};
await publisher.PublishAsync(new TestEvent1());
// Event may not have yet been handled in background.
await Task.Delay(500);
// AsyncHandler1 should have 1 event.
// 1. TestEvent1
Assert.Equal(1, asyncHandler1.HandledEvents.Count);
Assert.Contains(asyncHandler1.HandledEvents, (e) => e is TestEvent1);
// AsyncHandler2 should have 1 event.
// 1. TestEvent1
Assert.Equal(1, asyncHandler2.HandledEvents.Count);
Assert.Contains(asyncHandler2.HandledEvents, (e) => e is TestEvent1);
// AsyncHandler3 should have 1 event.
// 1. TestEvent1
Assert.Equal(1, asyncHandler3.HandledEvents.Count);
Assert.Contains(asyncHandler3.HandledEvents, (e) => e is TestEvent1);
// Handler1 should have 1 event.
// 1. TestEvent1
Assert.Equal(1, handler1.HandledEvents.Count);
Assert.Contains(handler1.HandledEvents, (e) => e is TestEvent1);
// Handler2 should have 1 event.
// 1. TestEvent1
Assert.Equal(1, handler2.HandledEvents.Count);
Assert.Contains(handler2.HandledEvents, (e) => e is TestEvent1);
// Handler3 should have 1 event.
// 1. TestEvent1
Assert.Equal(1, handler3.HandledEvents.Count);
Assert.Contains(handler3.HandledEvents, (e) => e is TestEvent1);
}
public void EventListenerReceivesMessageAsync(string firstName, string lastName, string email, string phone)
{
// Arrange
using var busContext = new RabbitMqContextBuilder()
.WithExchange("TestExchange")
.WithConnectionString("amqp://*****:*****@localhost")
.CreateContext();
using var host = new MicroserviceHostBuilder()
.WithBusContext(busContext)
.AddEventListener <PersonEventListener>()
.CreateHost();
host.Start();
var publisher = new EventPublisher(busContext);
var personEvent = new PersonAddedEvent {
Person = new Person
{
FirstName = firstName,
LastName = lastName,
Email = email,
PhoneNumber = phone
}
};
// Act
publisher.PublishAsync(personEvent);
Thread.Sleep(WaitTime);
// Assert
Assert.AreEqual(personEvent, PersonEventListener.ResultEvent);
}
public void PublishAsyncCallsSendMessageWithExpectedMessageOnSender(string topic, string body)
{
// Arrange
Mock <IBusContext <IConnection> > contextMock = new Mock <IBusContext <IConnection> >();
Mock <IMessageSender> senderMock = new Mock <IMessageSender>();
contextMock.Setup(e => e.CreateMessageSender())
.Returns(senderMock.Object);
EventMessage result = new EventMessage();
senderMock.Setup(e => e.SendMessage(It.IsAny <EventMessage>()))
.Callback <EventMessage>(e => result = e);
EventPublisher publisher = new EventPublisher(contextMock.Object);
TestEvent domainEvent = new TestEvent(topic)
{
DataField = body
};
string jsonBody = JsonConvert.SerializeObject(domainEvent);
// Act
publisher.PublishAsync(domainEvent);
Thread.Sleep(AsyncWaitTime);
// Assert
Assert.AreEqual(topic, result.Topic);
Assert.AreEqual(jsonBody, Encoding.Unicode.GetString(result.Body));
Assert.AreEqual(domainEvent.Timestamp, result.Timestamp);
Assert.AreEqual(domainEvent.Id, result.CorrelationId);
}
public async Task PublishAsync_SendsPublishCommandWithGivenEvent(string key, string value)
{
var now = DateTime.Now;
var configurationChangedEvent = new ConfigurationChangedEvent(key, value, now);
await _publisher.PublishAsync(configurationChangedEvent);
_fixture.MockConnectionMultiplexer.Verify(x => x.GetSubscriber(It.IsAny <object>()), Times.Once);
_fixture.MockSubscriber.Verify(x => x.PublishAsync(ConfigurationChangedEvent.EventName, JsonConvert.SerializeObject(configurationChangedEvent), It.IsAny <CommandFlags>()), Times.Once);
}
static void Main(string[] args)
{
//add event subscriptions
EventSubscriptions.Add <EmailOrderConfirmation>();
EventSubscriptions.Add <NotifyWarehouse>();
EventSubscriptions.Add <DeductOnHandInventory>();
//publish
IEventPublisher eventPublisher = new EventPublisher(new EventSubscriptions());
eventPublisher.PublishAsync <OrderSubmittedEvent>(new OrderSubmittedEvent {
OrderId = Guid.NewGuid().ToString()
});
eventPublisher.PublishAsync <OrderSubmittedEvent>(new OrderSubmittedEvent {
OrderId = Guid.NewGuid().ToString()
});
//Console.ReadKey();
}
protected override Task PublishModelCollectionLoadedEvent(IReadOnlyCollection <ContactAccountModel> contactAccountModelCollection)
{
NullGuard.NotNull(contactAccountModelCollection, nameof(contactAccountModelCollection));
lock (SyncRoot)
{
EventPublisher.PublishAsync(new ContactAccountModelCollectionLoadedEvent(DbContext, contactAccountModelCollection, StatusDate))
.GetAwaiter()
.GetResult();
}
return(Task.CompletedTask);
}
public async Task Should_Be_Good_If_No_Event_Handler_Is_Registered_In_Container()
{
var container = new Container();
var adapter = new SimpleInjectorContainerAdapter(container);
var eventHandlerResolver = new ContainerEventHandlerResolver(adapter);
var publisher = new EventPublisher(eventHandlerResolver);
publisher.OnError += (@event, ex) =>
{
_testOutputHelper.WriteLine(ex.Message);
};
await publisher.PublishAsync(new TestEvent1());
}
public void Send(string address, string subject, string content, ITransactionContext?transactionContext)
{
if (subject.IsNullOrEmpty())
{
throw ResponseException.ArgError("邮件标题不能为空");
}
if (!Mail.LimitCheck(address, subject))
{
throw ResponseException.LogicalError("操作过于频繁");
}
EventPublisher.PublishAsync(new SendMailEvent()
{
Address = address, Subject = subject, Content = content
}, transactionContext).Wait();
}
public Task Should_Throw_If_Null_Is_Being_Published()
{
return(Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
var registration = new EventHandlerRegistration();
var publisher = new EventPublisher(registration);
try
{
await publisher.PublishAsync((IEvent)null);
}
catch (Exception ex)
{
_testOutputHelper.WriteLine(ex.Message);
throw;
}
}));
}
public async Task Should_Trigger_OnError_If_EventHandlerAttributeRegistration_Produces_Null_Instance()
{
var registration = new EventHandlerAttributeRegistration();
// Produces null.
registration.Register <TestAttributedEventHandler1>(() => null);
var publisher = new EventPublisher(registration);
publisher.OnError += (eventHandler, ex) =>
{
_testOutputHelper.WriteLine(ex.Message);
Assert.IsType <InvalidOperationException>(ex);
};
await publisher.PublishAsync(new TestEvent1());
}
public async Task Should_Invoke_All_Registered_Event_Handlers_In_Attribute_Registration()
{
var attributedHandler1 = new TestAttributedEventHandler1(_testOutputHelper);
var attributedHandler2 = new TestAttributedEventHandler2(_testOutputHelper);
var attributedHandler3 = new TestAttributedEventHandler3(_testOutputHelper);
var registration = new EventHandlerAttributeRegistration();
registration.Register(() => attributedHandler1);
registration.Register(() => attributedHandler2);
registration.Register(() => attributedHandler3);
var publisher = new EventPublisher(registration);
publisher.OnError += (eventHandler, ex) =>
{
_testOutputHelper.WriteLine(ex.Message);
};
await publisher.PublishAsync(new TestEvent1());
// Just to make sure that events have been processed.
await Task.Delay(200);
// Handler1 should have 2 events.
// It contains sync and async handlers for:
// 1. TestEvent
Assert.Equal(2, attributedHandler1.HandledEvents.Count);
Assert.Contains(attributedHandler1.HandledEvents, e => e is TestEvent1);
// Handler2 should have 2 events.
// It contains sync and async handlers for:
// 1. TestEvent
Assert.Equal(2, attributedHandler2.HandledEvents.Count);
Assert.Contains(attributedHandler2.HandledEvents, e => e is TestEvent1);
// Handler3 should have 2 events.
// It contains sync and async handlers for:
// 1. TestEvent
Assert.Equal(2, attributedHandler3.HandledEvents.Count);
Assert.Contains(attributedHandler3.HandledEvents, e => e is TestEvent1);
}
public void PublishAsyncCallsSendMessageOnSender()
{
// Arrange
Mock <IBusContext <IConnection> > contextMock = new Mock <IBusContext <IConnection> >();
Mock <IMessageSender> senderMock = new Mock <IMessageSender>();
contextMock.Setup(e => e.CreateMessageSender())
.Returns(senderMock.Object);
EventPublisher publisher = new EventPublisher(contextMock.Object);
TestEvent domainEvent = new TestEvent("Topic");
// Act
publisher.PublishAsync(domainEvent);
Thread.Sleep(AsyncWaitTime);
// Assert
senderMock.Verify(e => e.SendMessage(It.IsAny <EventMessage>()), Times.Once);
}
public async Task When_a_single_event_is_published_to_the_bus_containing_a_single_EventHandler()
{
var testEvent = new TestEvent(Guid.NewGuid());
var handler = new FirstTestEventHandler();
var handlers = new List <Action <TestEvent> >
{
evt => handler.ExecuteAsync(evt)
};
var eventRouter = CreateEventRouter(handlers);
EventPublisher eventPublisher = new EventPublisher(eventRouter);
await eventPublisher.PublishAsync <IDomainEvent>(new[] { testEvent }).ConfigureAwait(false);
await eventPublisher.CommitAsync().ConfigureAwait(false);
handler.Ids.First().Should().Be(testEvent.AggregateId);
}
public async Task Should_Invoke_All_Registered_Event_Handlers_In_Container()
{
var container = new Container();
container.RegisterCollection(typeof(IEventAsyncHandler <>), typeof(TestEvent1).Assembly);
container.RegisterCollection(typeof(IEventHandler <>), typeof(TestEvent1).Assembly);
container.Register(() => _testOutputHelper);
var adapter = new SimpleInjectorContainerAdapter(container);
var eventHandlerResolver = new ContainerEventHandlerResolver(adapter);
var publisher = new EventPublisher(eventHandlerResolver);
publisher.OnError += (@event, ex) =>
{
_testOutputHelper.WriteLine(ex.Message);
Assert.IsType <TestEventHandlerException>(ex);
};
await publisher.PublishAsync(new TestEvent1());
}
public async Task Should_Invoke_All_Registered_Event_Handlers_In_Attribute_Registration_For_Each_Events()
{
var attributedHandler1 = new TestAttributedEventHandler1(_testOutputHelper);
var attributedHandler2 = new TestAttributedEventHandler2(_testOutputHelper);
var attributedHandler3 = new TestAttributedEventHandler3(_testOutputHelper);
var registration = new EventHandlerAttributeRegistration();
registration.Register(() => attributedHandler1);
registration.Register(() => attributedHandler2);
registration.Register(() => attributedHandler3);
var publisher = new EventPublisher(registration);
publisher.OnError += (@event, ex) =>
{
_testOutputHelper.WriteLine(ex.Message);
};
await publisher.PublishAsync(new List <IEvent> {
new TestEvent1(), new TestEvent2(), new TestEvent3()
});
}
public async Task Should_Invoke_All_Registered_Event_Handlers_In_Container_For_Each_Events()
{
var container = new Container();
container.RegisterCollection(typeof(IEventAsyncHandler <>), typeof(TestEvent1).Assembly);
container.RegisterCollection(typeof(IEventHandler <>), typeof(TestEvent1).Assembly);
container.Register(() => _testOutputHelper);
var adapter = new SimpleInjectorContainerAdapter(container);
var eventHandlerResolver = new ContainerEventHandlerResolver(adapter);
var publisher = new EventPublisher(eventHandlerResolver);
publisher.OnError += (@event, ex) =>
{
_testOutputHelper.WriteLine(ex.Message);
};
await publisher.PublishAsync(new List <IEvent> {
new TestEvent1(), new TestEvent2(), new TestEvent3()
});
// Event may not have yet been handled in background.
await Task.Delay(500);
}