public Domain.Deelnemer.Deelnemer Get(Guid id)
{
var repo = new EventSourcedAggregateRepository<PensioenSysteem.Domain.Deelnemer.Deelnemer>(
new FileEventStore(new RabbitMQEventPublisher()));
var deelnemer = repo.GetById(id);
return deelnemer;
}
public Domain.Deelnemer.Deelnemer Get(Guid id)
{
var repo = new EventSourcedAggregateRepository <PensioenSysteem.Domain.Deelnemer.Deelnemer>(
new FileEventStore(new RabbitMQEventPublisher()));
var deelnemer = repo.GetById(id);
return(deelnemer);
}
public Domain.Arbeidsverhouding.Arbeidsverhouding Get(Guid id)
{
var repo = new EventSourcedAggregateRepository <PensioenSysteem.Domain.Arbeidsverhouding.Arbeidsverhouding>(
new FileEventStore(new RabbitMQEventPublisher()));
var arbeidsverhouding = repo.GetById(id);
return(arbeidsverhouding);
}
public HttpResponseMessage Create([FromBody] RegistreerDeelnemerCommand command)
{
var deelnemer = new PensioenSysteem.Domain.Deelnemer.Deelnemer();
deelnemer.Registreer(command);
var repo = new EventSourcedAggregateRepository<PensioenSysteem.Domain.Deelnemer.Deelnemer>(
new FileEventStore(new RabbitMQEventPublisher()));
repo.Save(deelnemer, -1);
return new HttpResponseMessage(HttpStatusCode.Created);
}
void WithRepository <TAggregate>(Action <AggregateRepository <TAggregate> > work)
where TAggregate : class, Aggregate
{
WithEventstore(
(eventstore) =>
{
AggregateRepository <TAggregate> repository =
new EventSourcedAggregateRepository <TAggregate>(eventstore);
work(repository);
});
}
public async Task GetAsync_FilterReplacesReturnValue()
{
var replacementEntity = new MyEntity2(Guid.NewGuid(), 5);
repositoryFilter1.FilterResult <IEventSourcedAggregateRoot>(null)
.ReturnsForAnyArgs(replacementEntity);
sut = new EventSourcedAggregateRepository(eventStore, entityTypeManager, publishEventBuffer,
new[] { repositoryFilter1 }, eventMessageFactory, new EntityFactory());
Assert.Equal(replacementEntity, await sut.GetAsync <MyEntity2>(entity2Id));
}
public async Task GetAsync_FilterGetsCalled()
{
repositoryFilter1.FilterResult <IEventSourcedAggregateRoot>(null)
.ReturnsForAnyArgs(ci => ci.ArgAt <IEventSourcedAggregateRoot>(0));
sut = new EventSourcedAggregateRepository(eventStore, entityTypeManager, publishEventBuffer,
new[] { repositoryFilter1 }, eventMessageFactory, new EntityFactory());
await sut.GetAsync <MyEntity2>(entity2Id);
repositoryFilter1.Received(1).FilterResult <IEventSourcedAggregateRoot>(Arg.Is <IEventSourcedAggregateRoot>(x => x.Id == entity2Id));
}
public void Save(TAggregate aggregate)
{
cache.AddOrUpdate(
aggregate.AggregateId,
aggregate,
(id, current) => current.Revision <= aggregate.Revision ? aggregate : current);
AggregateRepository <TAggregate> repository =
new EventSourcedAggregateRepository <TAggregate>(aggregateEventStore);
repository.Save(aggregate);
}
public HttpResponseMessage Create([FromBody] RegistreerDeelnemerCommand command)
{
var deelnemer = new PensioenSysteem.Domain.Deelnemer.Deelnemer();
deelnemer.Registreer(command);
var repo = new EventSourcedAggregateRepository <PensioenSysteem.Domain.Deelnemer.Deelnemer>(
new FileEventStore(new RabbitMQEventPublisher()));
repo.Save(deelnemer, -1);
return(new HttpResponseMessage(HttpStatusCode.Created));
}
public HttpResponseMessage Create([FromBody] RegistreerArbeidsverhoudingCommand command)
{
var arbeidsverhouding = new PensioenSysteem.Domain.Arbeidsverhouding.Arbeidsverhouding();
arbeidsverhouding.Registreer(command);
var repo = new EventSourcedAggregateRepository <PensioenSysteem.Domain.Arbeidsverhouding.Arbeidsverhouding>(
new FileEventStore(new RabbitMQEventPublisher()));
repo.Save(arbeidsverhouding, -1);
return(new HttpResponseMessage(HttpStatusCode.Created));
}
public TAggregate GetById(Guid aggregateId)
{
TAggregate aggregate;
if (cache.TryGetValue(aggregateId, out aggregate))
{
return(aggregate);
}
AggregateRepository <TAggregate> repository =
new EventSourcedAggregateRepository <TAggregate>(aggregateEventStore);
aggregate = repository.GetById(aggregateId);
cache.TryAdd(aggregateId, aggregate);
return(aggregate);
}
public HttpResponseMessage Verhuis(Guid id, [FromBody] VerhuisDeelnemerCommand command)
{
var repo = new EventSourcedAggregateRepository<PensioenSysteem.Domain.Deelnemer.Deelnemer>(
new FileEventStore(new RabbitMQEventPublisher()));
Domain.Deelnemer.Deelnemer deelnemer;
try
{
deelnemer = repo.GetById(id);
}
catch (AggregateNotFoundException ex)
{
return new HttpResponseMessage(HttpStatusCode.NotFound);
}
deelnemer.Verhuis(command);
repo.Save(deelnemer, command.Version);
return new HttpResponseMessage(HttpStatusCode.OK);
}
public async Task SaveChangesAsync_FiltersAdded()
{
sut = new EventSourcedAggregateRepository(eventStore, entityTypeManager, publishEventBuffer,
new[] { repositoryFilter1 }, eventMessageFactory, new EntityFactory());
var entity = new MyEntity(entityId, 5);
sut.Add(entity);
entity.UncommittedEvents = new List <DomainAggregateEvent>()
{
new SetFooEvent()
{
AggregateId = entityId
}
};
await sut.SaveChangesAsync();
repositoryFilter1.Received(1).FilterAdded(entity);
}
public HttpResponseMessage Verhuis(Guid id, [FromBody] VerhuisDeelnemerCommand command)
{
var repo = new EventSourcedAggregateRepository <PensioenSysteem.Domain.Deelnemer.Deelnemer>(
new FileEventStore(new RabbitMQEventPublisher()));
Domain.Deelnemer.Deelnemer deelnemer;
try
{
deelnemer = repo.GetById(id);
}
catch (AggregateNotFoundException ex)
{
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}
deelnemer.Verhuis(command);
repo.Save(deelnemer, command.Version);
return(new HttpResponseMessage(HttpStatusCode.OK));
}
public EventSourcedRepositoryTests()
{
publishEventBuffer = Substitute.For <IPublishEventBuffer>();
eventStore = Substitute.For <IEventStore>();
entityTypeManager = Substitute.For <IEntityTypeManager>();
repositoryFilter1 = Substitute.For <IRepositoryFilter>();
repositoryFilter2 = Substitute.For <IRepositoryFilter>();
FakeClock.Setup();
eventStore.GetEventsAsync(entity2Id)
.Returns(new List <IEventStoreRecord>()
{
new FakeEventStoreRecord()
{
Event = new SetFooEvent()
{
AggregateId = entity2Id
},
StreamSequenceNumber = 1
}
});
eventStore.GetStreamMetadataAsync(entity2Id)
.Returns(new Dictionary <string, string>()
{
{ "TestKey", "TestValue" },
{ AggregateEventStreamMetadataNames.ClassId, entity2ClassId.ToString() }
});
eventStore.GetStreamMetadataAsync(entity3Id)
.Returns(new Dictionary <string, string>()
{
{ "TestKey", "TestValue" },
{ AggregateEventStreamMetadataNames.ClassId, entity3ClassId.ToString() }
});
eventStore.PushEventsAsync(Guid.Empty, null, null).ReturnsForAnyArgs(ci =>
{
var events = ci.ArgAt <IEnumerable <IUncommittedEventStoreRecord> >(1);
return(events.Select(x => new FakeEventStoreRecord()
{
AdditionalMetadata = x.Metadata,
Event = x.Event,
EventId = Guid.NewGuid(),
StoreDate = DateTimeOffset.Now,
StreamSequenceNumber = 0
}).ToList());
});
DomainClassInfo[] domainClasses = new[]
{
new DomainClassInfo(entityClassId, null, typeof(MyEntity)),
new DomainClassInfo(entity2ClassId, null, typeof(MyEntity2)),
new DomainClassInfo(entity3ClassId, null, typeof(MyEntity3LoadsAsDeleted))
};
entityTypeManager.GetClassInfoByClassId(Guid.Empty)
.ReturnsForAnyArgs(ci => domainClasses.Single(x => x.Id == ci.Arg <Guid>()));
entityTypeManager.TryGetClassInfoByClrType(null)
.ReturnsForAnyArgs(ci => domainClasses.SingleOrDefault(x => x.ClrType == ci.Arg <Type>()));
entityTypeManager.GetClassInfoByClrType(null)
.ReturnsForAnyArgs(ci => domainClasses.Single(x => x.ClrType == ci.Arg <Type>()));
eventMessageFactory = Substitute.For <IEventMessageFactory>();
eventMessageFactory.CreateMessageAsync(null).ReturnsForAnyArgs(ci =>
{
var @event = ci.ArgAt <IEvent>(0);
Type messageType = typeof(EventMessageDraft <>).MakeGenericType(@event.GetType());
IEventMessageDraft messageDraft = (IEventMessageDraft)messageType.GetConstructor(new[] { @event.GetType() }).Invoke(new[] { @event });
messageDraft.SetMetadata("TestKey", "TestValue");
return(messageDraft);
}); // TODO something more lightweight?
sut = new EventSourcedAggregateRepository(eventStore,
entityTypeManager, publishEventBuffer, new IRepositoryFilter[] {}, eventMessageFactory, new EntityFactory());
}
public async Task DefaultFilters_GetsInitialFilters()
{
sut = new EventSourcedAggregateRepository(eventStore, entityTypeManager, publishEventBuffer,
new[] { repositoryFilter1 }, eventMessageFactory, new EntityFactory());
Assert.True(sut.DefaultFilters.SequenceEqual(new IRepositoryFilter[] { repositoryFilter1 }));
}
