public async Task StoreEvents_WillStoreMappedEvents_WhenStreamExistsAndIsNotBroken()
{
// arrange
var streamId = Guid.NewGuid();
var eventMetadata = new Metadata(streamId, typeof (TestAggregateChanged));
var currentStreamVersion = Fixture.Create<long>();
var event1 = Fixture
.Build<TestAggregateChanged>()
.With(e => e.Metadata, eventMetadata)
.Create();
var event2 = Fixture
.Build<TestAggregateChanged>()
.With(e => e.Metadata, eventMetadata)
.Create();
var lastStreamEvent = new StoredEvent(
typeof (TestAggregateCreated).AssemblyQualifiedName,
Fixture.Create<DateTime>(),
Fixture.Create<string>(),
Guid.NewGuid(),
currentStreamVersion);
A.CallTo(() => Faker.Resolve<IEventRepository>()
.GetLast(streamId))
.Returns(Task.FromResult(lastStreamEvent));
var event1Serialiazed = Fixture.Create<string>();
var event2Serialiazed = Fixture.Create<string>();
A.CallTo(() => Faker.Resolve<IEventSerializer>()
.Serialize(event1))
.Returns(event1Serialiazed);
A.CallTo(() => Faker.Resolve<IEventSerializer>()
.Serialize(event2))
.Returns(event2Serialiazed);
var batchId = Guid.NewGuid();
Faker.Provide<Func<Guid>>(() => batchId);
var expectedEventName = typeof (TestAggregateChanged).AssemblyQualifiedName;
var expectedEvents = new List<StoredEvent>
{
new StoredEvent(expectedEventName, event1.Metadata.OccorredOn, event1Serialiazed, batchId, currentStreamVersion + 1),
new StoredEvent(expectedEventName, event2.Metadata.OccorredOn, event2Serialiazed, batchId, currentStreamVersion + 2)
};
var sut = Faker.Resolve<EventStore>();
// act
await sut
.StoreEvents(streamId, currentStreamVersion, new DomainEvent[] { event1, event2 })
.ConfigureAwait(false);
// assert
A.CallTo(() => Faker.Resolve<IEventRepository>()
.Add(
streamId,
A<ICollection<StoredEvent>>.That.Matches(evts => expectedEvents.All(evts.Contains))))
.MustHaveHappened(Repeated.Exactly.Once);
}
public void StoreEvents_WillThrowException_WhenStreamExistsAndIsBroken()
{
// arrange
var streamId = Guid.NewGuid();
var eventMetadata = new Metadata(streamId, typeof(TestAggregateChanged));
var currentStreamVersion = Fixture.Create<long>();
var event1 = Fixture
.Build<TestAggregateChanged>()
.With(e => e.Metadata, eventMetadata)
.Create();
var event2 = Fixture
.Build<TestAggregateChanged>()
.With(e => e.Metadata, eventMetadata)
.Create();
var lastStreamEvent = new StoredEvent(
typeof(TestAggregateCreated).AssemblyQualifiedName,
Fixture.Create<DateTime>(),
Fixture.Create<string>(),
Guid.NewGuid(),
currentStreamVersion + 1);
A.CallTo(() => Faker.Resolve<IEventRepository>()
.GetLast(streamId))
.Returns(Task.FromResult(lastStreamEvent));
Faker.Provide<Func<Guid>>(Guid.NewGuid);
var sut = Faker.Resolve<EventStore>();
Func<Task> exceptionThrower = async () => await sut
.StoreEvents(streamId, currentStreamVersion, new DomainEvent[] { event1, event2 })
.ConfigureAwait(false);
// act & assert
exceptionThrower
.ShouldThrow<InvalidOperationException>()
.And
.Message
.Should()
.Contain($"Cant add new events on version {currentStreamVersion} as current storage version is {lastStreamEvent.EventId}");
A.CallTo(() => Faker.Resolve<IEventRepository>()
.Add(streamId, A<ICollection<StoredEvent>>._))
.MustNotHaveHappened();
}
public async Task LoadAllEvents_WillLoadAndMapAllEvents_WhenThereAreStoredEvents()
{
// arrange
var streamId = Guid.NewGuid();
var event1Metadata = new Metadata(streamId, typeof(TestAggregateChanged))
{
StorageVersion = 1L
};
var event2Metadata = new Metadata(streamId, typeof(TestAggregateChanged))
{
StorageVersion = 2L
};
var typeName = typeof(TestAggregateChanged).AssemblyQualifiedName;
var event1 = Fixture
.Build<TestAggregateChanged>()
.With(e => e.Metadata, event1Metadata)
.Create();
var event2 = Fixture
.Build<TestAggregateChanged>()
.With(e => e.Metadata, event2Metadata)
.Create();
var expectedEvents = new List<DomainEvent>
{
event1,
event2
};
var event1Serialized = Fixture.Create<string>();
var event2Serialized = Fixture.Create<string>();
var batchId = Guid.NewGuid();
var storedEvents = new List<StoredEvent>
{
new StoredEvent(typeName, event1Metadata.OccorredOn, event1Serialized, batchId, event1Metadata.StorageVersion),
new StoredEvent(typeName, event2Metadata.OccorredOn, event2Serialized, batchId, event2Metadata.StorageVersion)
};
A.CallTo(() => Faker.Resolve<IEventRepository>()
.CheckStream(streamId))
.Returns(true);
A.CallTo(() => Faker.Resolve<IEventRepository>()
.GetAll(streamId))
.Returns(storedEvents);
A.CallTo(() => Faker.Resolve<IEventSerializer>()
.Deserialize(event1Serialized, typeof(TestAggregateChanged)))
.Returns(event1);
A.CallTo(() => Faker.Resolve<IEventSerializer>()
.Deserialize(event2Serialized, typeof(TestAggregateChanged)))
.Returns(event2);
Faker.Provide<Func<Guid>>(Guid.NewGuid);
var sut = Faker.Resolve<EventStore>();
// act
var events = await sut
.LoadAllEvents(streamId)
.ConfigureAwait(false);
// assert
events
.ShouldAllBeEquivalentTo(expectedEvents);
}
protected DomainEvent(Guid aggregateRootId)
{
Metadata = new Metadata(aggregateRootId, GetType());
}
