public void WhenCreating_AndDeclaringAsABaseClass_ShouldSetEventTypeAsGenericBaseClass()
{
var eventData = NewEventData.Create <Something>(new SubSomething());
// The EventType should be based on the actual concrete class of the event. Not the base class.
eventData.EventType.Should().Be(typeof(Something).FullName);
}
public void WhenCreating_AndDeclaringAsObject_ShouldSetEventTypeAsMostSpecificType() // when using params array, you probably don't wish to publish 'object's
{
var eventData = NewEventData.Create <object>(new SubSomething());
// The EventType should be based on the actual concrete class of the event. Not the genmeric-declared class.
eventData.EventType.Should().Be(typeof(SubSomething).FullName);
}
public void WhenCreatingWithoutSpecifyingEventId_ShouldCreateAnEventId()
{
var expectedData = new { Id = 123, Foo = "bar" };
var eventData = NewEventData.Create(expectedData);
eventData.EventId.Should().NotBeEmpty();
}
public void WhenCreating_ShouldSetMetadataCorrectly()
{
var metadata = new { Id = 123, Foo = "bar" };
var eventData = NewEventData.Create("something", metadata);
eventData.Metadata.Should().Be(metadata);
}
public void WhenCreating_ShouldSetDataCorrectly()
{
var expectedData = new { Id = 123, Foo = "bar" };
var eventData = NewEventData.Create(expectedData);
eventData.Data.Should().Be(expectedData);
}
public void WhenCreatingAndSpecifyingEventId_ShouldUsedPassedEventId()
{
var expectedData = new { Id = 123, Foo = "bar" };
var expectedId = Guid.NewGuid();
var eventData = NewEventData.Create(expectedId, expectedData);
eventData.EventId.Should().Be(expectedId);
}
async Task InsertRefundOrder(long orderId, decimal amount, Guid conversationId)
{
RefundOrder refundOrder = new RefundOrder();
refundOrder.OrderId = orderId;
refundOrder.Amount = amount;
refundOrder.ConversationId = conversationId;
NewEventData @event = NewEventData.Create(refundOrder);
await Connection.AppendToStreamAsync(OrderDeliveredStreamName, ExpectedVersion.Any, @event);
}
async Task InsertOrderDelivered(IEnumerable <SampleOrder> sampleOrders)
{
foreach (SampleOrder sampleOrder in sampleOrders)
{
OrderDelivered d = new OrderDelivered
{
ConversationId = sampleOrder.ConversationId,
OrderId = sampleOrder.OrderId,
};
NewEventData @event = NewEventData.Create(d);
await Connection.AppendToStreamAsync(OrderDeliveredStreamName, ExpectedVersion.Any, @event);
}
}
async Task InsertRemovedToBasket(IEnumerable <SampleOrder> sampleOrders, string product)
{
foreach (SampleOrder sampleOrder in sampleOrders)
{
ProductRemovedFromBasket d = new ProductRemovedFromBasket
{
ConversationId = sampleOrder.ConversationId,
CustomerId = sampleOrder.OrderId + 1000,
Product = product,
};
NewEventData @event = NewEventData.Create(d);
await Connection.AppendToStreamAsync(ProductRemovedFromBasketStreamName, ExpectedVersion.Any, @event);
}
}
async Task InsertPaymentCaptured(IEnumerable <SampleOrder> sampleOrders)
{
foreach (SampleOrder sampleOrder in sampleOrders)
{
PaymentCaptured d = new PaymentCaptured
{
ConversationId = sampleOrder.ConversationId,
Amount = 25m,
OrderId = sampleOrder.OrderId,
Currency = "GBP"
};
NewEventData @event = NewEventData.Create(d);
await Connection.AppendToStreamAsync(PaymentCapturedStreamName, ExpectedVersion.Any, @event);
}
}
private async Task AppendToStreamTest(int expectedVersion, NewEventData data, Action <HttpClient, HttpRequestMessage> test)
{
var called = false;
_httpClientProxyMock.Setup(x => x.SendAsync(It.IsAny <HttpClient>(), It.IsAny <HttpRequestMessage>()))
.ReturnsAsync(new HttpResponseMessage(HttpStatusCode.OK))
.Callback <HttpClient, HttpRequestMessage>(
(client, request) =>
{
test(client, request);
called = true;
});
await _connection.AppendToStreamAsync(StreamName, expectedVersion, data);
called.Should().BeTrue();
}
async Task InsertOrderCreated(IEnumerable <SampleOrder> sampleOrders)
{
List <string> products = new List <string>();
products.Add("Burger");
products.Add("Pizza");
products.Add("Drinks");
foreach (SampleOrder sampleOrder in sampleOrders)
{
OrderCreated d = new OrderCreated
{
ConversationId = sampleOrder.ConversationId,
Amount = 25m,
ProductList = products,
CustomerId = sampleOrder.OrderId + 1000,
OrderId = sampleOrder.OrderId
};
NewEventData @event = NewEventData.Create(d);
await Connection.AppendToStreamAsync(OrderCreatedStreamName, ExpectedVersion.Any, @event);
}
}
public void WhenCreating_AndNotSpeifyingAGenericType_ShouldSetEventTypeAsMostSpecificType()
{
var eventData = NewEventData.Create(new Something());
eventData.EventType.Should().Be(typeof(Something).FullName);
}
private async Task SaveToEventStore(dynamic token)
{
dynamic messageDetails = JObject.Parse(token.Message.ToString());
NewEventData @event = NewEventData.Create(messageDetails);
await _eventStore.AppendToStreamAsync(token.Subject.ToString(), ExpectedVersion.Any, @event);
}
private async Task AppendToStreamTest(int expectedVersion, NewEventData data, Action<HttpClient, HttpRequestMessage> test)
{
var called = false;
_httpClientProxyMock.Setup(x => x.SendAsync(It.IsAny<HttpClient>(), It.IsAny<HttpRequestMessage>()))
.ReturnsAsync(new HttpResponseMessage(HttpStatusCode.OK))
.Callback<HttpClient, HttpRequestMessage>(
(client, request) =>
{
test(client, request);
called = true;
});
await _connection.AppendToStreamAsync(StreamName, expectedVersion, data);
called.Should().BeTrue();
}
