Building an Event Driven Architecture – Lessons Learned

2020-02-25T21:11:06+01:00

robin 3 years ago Reply

Hi,

Interesting read. I was wondering how your application package/module structure looks like. More specifically where do you put the event handlers in het ports and adapters architecture?

Thanks

2020-02-26T18:24:26+01:00

artineering 3 years ago Reply

We have a separation between event handlers (which are domain concerns and live in the domain project) and a message “pump” (that listens on queues for these messages and is a part of a messaging adapter project). These messages are then converted into events in the domain and dispatched to event handlers for actual processing. You can see this delineation in the hexagon diagram in the post.

Sorry can’t seem to be able to attach screenshots in comments! I will add one to the post later.

Pingback: Some More Lessons Learned in Event Driven Architectures – Artineering

	namespace Domain.ProductInformation.EventHandlers
	{
	public class ProductInformationHandler :
	IHandleEvents<ProductInformation>
	{
	private readonly ReviewUsecase _reviewUseCase;
	private readonly IStorePurchaseOrders _purchaseOrderStore;
	private readonly IStoreProducts _productStore;

	public ProductInformationHandler(
	ReviewUsecase reviewUseCase,
	IStorePurchaseOrders purchaseOrderStore,
	IStoreProducts productStore)
	{
	_reviewUseCase = reviewUseCase;
	_purchaseOrderStore = purchaseOrderStore;
	_productStore = productStore;
	}

	public async Task Handle(ProductInformation eventToHandle)
	{
	var product = eventToHandle.ToEntity();
	await _productStore.Save();

	var purchaseOrderItems = await _purchaseOrderStore
	.GetFor(eventToHandle.ProductId);

	foreach (var item in purchaseOrderItems)
	{
	await _reviewUseCase.Execute(item, product);
	}
	}
	}
	}

	public class GivenThereArePurchaseOrdersForTheProduct
	{
	[Fact]
	public async Task ShouldCreateValidSuggestion()
	{
	var productId = {use a dummy id};
	// set up the stub to already have a purchase order stored
	var poStore = new PurchaseOrderStoreStub()
	.WithPurchaseOrder(...);

	var productStore = new ProductStoreStub();
	var suggestionStore = new SuggestionStoreStub();

	// initialise the System Under Test passing in all the stubbed dependencies

	var handler = new ProductInformationHandler(
	new ReviewUseCase(
	suggestionStore,
	productStore,
	poStore),
	poStore,
	productStore
	);

	// invoke the handle method (It doesn't matter if its invoked
	// via an event arriving in a queue or by a test suite like this one)

	// create a test event with canned values
	await handler.Handle(
	CreateTestEvent(...));

	// Time to assert on the output of handling the test event.

	var savedProduct = await productStore.GetByProductId(productId);
	var suggestionForProduct = await suggestionStore.GetFor(productId);

	// Assert that incoming product was saved successfully
	savedProduct.Should().NotBeNull();

	// Assert that as a result of an appropriate event, the suggestion was also created
	// and stored in the "database"
	suggestionForProduct.Should().NotBeNull();
	// various other assertions on suggestion attributes.
	}
	}

	namespace Domain.Tests.Unit.Stubs
	{
	internal class SubmissionServiceHttpHandlerStub : HttpMessageHandler
	{
	private Dictionary<string, Payload> _requestPayload;

	protected override async Task<HttpResponseMessage> SendAsync(
	HttpRequestMessage request,
	CancellationToken cancellationToken)
	{
	_payload = JsonConvert.DeserializeObject<Dictionary<string,
	Payload>>(
	await request.Content.ReadAsStringAsync());

	// Assume that submission was successful,
	// construct the response payload
	var result = ConstructResponsePayload(_payload)

	return new HttpResponseMessage(HttpStatusCode.OK)
	{
	Content = new StringContent(JsonConvert.SerializeObject(result))
	};
	}

	internal Payload PayloadDto(
	string key) =>
	_payload[key].FirstOrDefault();
	}
	}

	[Fact]
	public async Task ShouldSubmitCorrectPayload()
	{
	// ... Do all the set up required i.e. stubs, domain objects
	// with pre-cooked data neccesary to execute the behaviour.

	// Build the service/adapter object with this mock HttpMessageHandler
	var loopbackHttpHandler = new SubmissionServiceHttpHandlerStub();

	var submitter = new SubmissionService(
	new HttpClient(loopbackHttpHandler)
	{
	BaseAddress = new Uri("http://foo.bar")
	});

	var useCase = CreateUseCase(submitter);
	useCase.Execute(...);

	// verify that what will have been submitted to the external
	// service would have been the right data
	var payload = loopbackHttpHandler.PayloadDto("key");
	payload.Field1.Should().Be("abc");
	payload.Field2.Should().Be(10);
	// other assertions
	}

	namespace PurchaseOrderAdapter
	{
	public class AlwaysCancelPurchaseOrderLineSuccessfully
	: ICancelPurchaseOrderLine
	{
	public Task<Result> Cancel(
	PurchaseOrderLine purchaseOrderLine)
	{
	// simulate success while calling an "external" service
	return Task.FromResult(Success(
	purchaseOrderLine));
	}
	}
	}

Published by Aman Agrawal

3 Replies to “Building an Event Driven Architecture – Lessons Learned”

Leave a Reply Cancel reply

	public void RegisterServices()
	{
	// while running the service locally, mock external call
	// so it always succeeds (as long as it
	// itself is not the subject of the test)
	var isDevelopmentEnvironment = DetermineCurrentEnvironment();

	if (isDevelopmentEnvironment)
	webserviceContainer.Register<ICancelPurchaseOrderLine,
	AlwaysCancelPurchaseOrderLineSuccessfully>();
	else // otherwise use the actual live web service adapter
	webserviceContainer.Register<ICancelPurchaseOrderLine,
	RealPurchaseOrderService>();
	}

Event Driven Back End:

Many Meanings of Event Driven:

Request Response Driven Front End:

Share this:

Like this:

Related

Published by Aman Agrawal

3 Replies to “Building an Event Driven Architecture – Lessons Learned”

Leave a Reply Cancel reply