public virtual async Task SaveAndLoadContainsAllEventsForAnAggregate()
{
_logger.LogInformation("Running SaveAndLoadContainsAllEventsForAnAggregate");
await Task.Delay(0).ConfigureAwait(false);
var store = CreateInstance();
{
var @event = FakeEvent.Create();
await store.SaveEventsAsync <FakeAggregate>(@event.AggregateId, new IDomainEvent[] { @event }, 0).ConfigureAwait(false);
var loaded = await store.GetEventsForAggregateAsync <FakeAggregate>(@event.AggregateId).ConfigureAwait(false);
loaded.Should().Contain(x => x.EventData.Id == @event.Id);
}
{
var save = FakeEvent.CreateList(155).ToArray();
await store.SaveEventsAsync <FakeAggregate>(save.First().AggregateId, save, 154).ConfigureAwait(false);
var loaded = await store.GetEventsForAggregateAsync <FakeAggregate>(save.First().AggregateId).ConfigureAwait(false);
foreach (var savedEvent in save)
{
loaded.Should().Contain(x => x.EventData.Id == savedEvent.Id);
}
}
}
public void CanCreateDomainEventMessages()
{
var ev = FakeEvent.Create();
var agg = FakeAggregate.Factory.Create("1");
{
var de = ev.CreateAggregateDomainEventMessage(agg);
de.AggregateId.Should().Be(agg.AggregateId);
de.AggregateType.Should().Be(agg.GetType().GetTypeShortName());
de.DomainEventType.Should().Be("SoftwarePioniere.FakeDomain.FakeEvent, SoftwarePioniere.TestHarness");
var pev = de.GetEvent <FakeEvent>();
pev.Id.Should().Be(ev.Id);
pev.Text.Should().Be(ev.Text);
pev.AggregateId.Should().Be(ev.AggregateId);
pev.TimeStampUtc.Should().Be(ev.TimeStampUtc);
pev.UserId.Should().Be(ev.UserId);
}
//{
// var de = (AggregateDomainEventMessage<FakeAggregate, FakeEvent>)ev.CreateTypedAggregateDomainEventMessage(agg);
// de.Should().NotBeNull();
// de.AggregateId.Should().Be(agg.Id);
// de.AggregateType.Should().Be(agg.GetType().GetTypeShortName());
// de.DomainEventType.Should().Be("SoftwarePioniere.Messaging.FakeEvent, SoftwarePioniere.Messaging.TestHarness");
// de.DomainEventContent.Id.Should().Be(ev.Id);
// de.DomainEventContent.Text.Should().Be(ev.Text);
// de.DomainEventContent.AggregateId.Should().Be(ev.AggregateId);
// de.DomainEventContent.TimeStampUtc.Should().Be(ev.TimeStampUtc);
// de.DomainEventContent.UserId.Should().Be(ev.UserId);
//}
}
public void CanParseToIMessage()
{
object message = FakeEvent.Create();
Type messageType = message.GetType();
var isIMessage = typeof(IMessage).IsAssignableFrom(messageType);
isIMessage.Should().BeTrue();
}
public virtual async Task SavesEventsWithExpectedVersion()
{
_logger.LogInformation("Running SavesEventsWithExpectedVersion");
var store = CreateInstance();
await Task.Delay(0).ConfigureAwait(false);
{
var agg = FakeAggregate.Factory.Create();
for (int i = 0; i < 133; i++)
{
agg.DoFakeEvent($"schleife {i}");
}
await store.SaveEventsAsync <FakeAggregate>(agg.AggregateId, agg.GetUncommittedChanges(), agg.Version).ConfigureAwait(false);
agg.MarkChangesAsCommitted();
agg.DoFakeEvent2("fake 2");
await store.SaveEventsAsync <FakeAggregate>(agg.AggregateId, agg.GetUncommittedChanges(), agg.Version).ConfigureAwait(false);
agg.MarkChangesAsCommitted();
var events = await store.GetEventsForAggregateAsync <FakeAggregate>(agg.AggregateId).ConfigureAwait(false);
var lastEvent = events.Last();
agg.Version.Should().Be(lastEvent.Version);
agg.DoFakeEvent2("fake 3");
Func <Task> f = async() =>
{
await store.SaveEventsAsync <FakeAggregate>(agg.AggregateId,
agg.GetUncommittedChanges(),
agg.Version + 99).ConfigureAwait(false);
};
f.Should().Throw <ConcurrencyException>();
}
{
var event1 = FakeEvent.Create();
await store.SaveEventsAsync <FakeAggregate>(event1.AggregateId, new IDomainEvent[] { event1 }, 0).ConfigureAwait(false);
await store.SaveEventsAsync <FakeAggregate>(event1.AggregateId, new IDomainEvent[] { FakeEvent.Create() }, 1).ConfigureAwait(false);
await store.SaveEventsAsync <FakeAggregate>(event1.AggregateId, new IDomainEvent[] { FakeEvent.Create() }, 2).ConfigureAwait(false);
await store.SaveEventsAsync <FakeAggregate>(event1.AggregateId, new IDomainEvent[] { FakeEvent.Create(), FakeEvent.Create() }, 4).ConfigureAwait(false);
}
}
public void ApplyHistoryEvents()
{
var agg = new FakeAggregate();
var @event = FakeEvent.Create();
agg.SetAggregateId(@event.AggregateId);
agg.LoadFromHistory(new[] { new EventDescriptor(@event, 1) });
agg.AggregateId.Should().Be(@event.AggregateId);
agg.Text.Should().Be(@event.Text);
}
public virtual async Task CheckAggregateExists()
{
_logger.LogInformation("Running CheckAggregateExists");
var @event = FakeEvent.Create();
var store = CreateInstance();
var exists = await store.CheckAggregateExists <FakeAggregate>(@event.AggregateId).ConfigureAwait(false);
exists.Should().BeFalse();
await store.SaveEventsAsync <FakeAggregate>(@event.AggregateId, new IDomainEvent[] { @event }, 0).ConfigureAwait(false);
exists = await store.CheckAggregateExists <FakeAggregate>(@event.AggregateId).ConfigureAwait(false);
exists.Should().BeTrue();
}
public virtual async Task SaveThrowsErrorIfVersionsNotMatch()
{
_logger.LogInformation("Running SaveThrowsErrorIfVersionsNotMatch");
var store = CreateInstance();
await Task.Delay(0).ConfigureAwait(false);
var event1 = FakeEvent.Create();
await store.SaveEventsAsync <FakeAggregate>(event1.AggregateId, new IDomainEvent[] { event1 }, 0).ConfigureAwait(false);
var event2 = FakeEvent.Create();
Func <Task> f = async() => { await store.SaveEventsAsync <FakeAggregate>(event1.AggregateId, new IDomainEvent[] { event2 }, 42).ConfigureAwait(false); };
f.Should().Throw <ConcurrencyException>(); //.WithInnerException<ConcurrencyException>();
}
public virtual async Task RegisteredEventHandlerWillBeCalledAsync()
{
ServiceCollection
.AddSingleton <IMessageSubscriber>(c => c.GetService <IMessageBus>())
.AddSingleton <IMessageHandler, FakeEventHandler>()
;
var bus = await CreateInstance().ConfigureAwait(false);
var @event = FakeEvent.Create();
await bus.PublishAsync(@event).ConfigureAwait(false);
await Task.Delay(1000).ConfigureAwait(false);
FakeEventHandler.HandledBy.Should().Contain(x => x == @event.Id);
}
public async Task LoadCreatesAggregateAsync()
{
var @event = FakeEvent.Create();
IList <EventDescriptor> list = new List <EventDescriptor> {
new EventDescriptor(@event, 0)
};
var mockStore = new Mock <IEventStore>();
mockStore.Setup(x => x.GetEventsForAggregateAsync <FakeAggregate>(@event.AggregateId))
.ReturnsAsync(list);
ServiceCollection
.AddSingleton(mockStore.Object)
.AddSingleton(Mock.Of <IMessagePublisher>())
;
var repo = CreateInstance();
var agg = await repo.GetByIdAsync <FakeAggregate>(@event.AggregateId);
agg.AggregateId.Should().Be(@event.AggregateId);
}
