public void should_throw_concurrency_exception_if_events_conflict()
{
var storage = Mock.Create <IEventStorage>();
var id = Guid.Empty;
Mock
.Arrange(() => storage.GetEventsForAggregate(id, serializer_, 1))
.Returns(new List <Event> {
new Modified()
});
Mock
.Arrange(() => storage
.SaveEvents(Arg.IsAny <Guid>(), Arg.IsAny <ICollection <Event> >(), 1,
serializer_))
.Throws(new WrongExpectedVersionException(string.Empty));
var repository = new Repository <DummyAggregate>(storage, serializer_,
AggregateFactories.FromFunc(guid => new DummyAggregate(guid)),
ConflictEvaluators.FromFunc((@event, event1) => true));
var aggregate = new DummyAggregate(Guid.Empty);
Assert.That(() => repository.Save(aggregate, 1),
Throws.TypeOf <ConcurrencyException>());
}
public async Task AppendAsync_should_throw_AggregateException_when_version_mismatch()
{
var db = await _fixture.CreateTestDatabaseAsync();
var sut = new EventsRepository <DummyAggregate, Guid>(db, _eventSerializer);
var aggregateId = Guid.NewGuid();
var tasks = Enumerable.Range(1, 3)
.Select(i =>
{
var aggregate = new DummyAggregate(aggregateId);
aggregate.DoSomething($"foo|{i}");
return(sut.AppendAsync(aggregate));
}).ToArray();
await Assert.ThrowsAsync <AggregateException>(async() => await Task.WhenAll(tasks));
}
public PropertyCommandTests()
{
this.teclyn = new TeclynApi(new TeclynTestConfiguration());
this.repositoryService = teclyn.Get <RepositoryService>();
this.commandService = teclyn.Get <CommandService>();
this.repositoryService.Register(typeof(DummyAggregate), typeof(DummyAggregate), typeof(DummyAggregate).Name, null, null);
this.aggregate = new DummyAggregate
{
Value = "value",
Id = aggregateId,
};
var repository = this.teclyn.Get <IRepository <DummyAggregate> >();
repository.Create(aggregate);
}
public async Task DispatchAsync_should_publish_events()
{
var topicFactory = new TopicClientFactory(_connStr);
var logger = NSubstitute.Substitute.For <ILogger <EventProducer <DummyAggregate, Guid> > >();
var sut = new EventProducer <DummyAggregate, Guid>(topicFactory, "test", _eventSerializer, logger);
await CreateTopicAsync(sut.TopicName);
int expectedMessagesCount = 3;
var subscriptionClient = new SubscriptionClient(_connStr, sut.TopicName, SubscriptionName);
subscriptionClient.RegisterMessageHandler(
async(msg, tkn) =>
{
--expectedMessagesCount;
await subscriptionClient.CompleteAsync(msg.SystemProperties.LockToken);
},
(ex) => Task.CompletedTask);
var aggregate = new DummyAggregate(Guid.NewGuid());
aggregate.DoSomething("lorem");
aggregate.DoSomething("ipsum");
await sut.DispatchAsync(aggregate);
var timeout = 30 * 1000;
var timer = new Stopwatch();
timer.Start();
while (true)
{
if (expectedMessagesCount < 1 || timer.ElapsedMilliseconds > timeout)
{
break;
}
await Task.Delay(200);
}
expectedMessagesCount.Should().Be(0);
}
public async Task AppendAsync_should_store_events()
{
var db = await _fixture.CreateTestDatabaseAsync();
var sut = new EventsRepository <DummyAggregate, Guid>(db, _eventSerializer);
var aggregate = new DummyAggregate(Guid.NewGuid());
aggregate.DoSomething("foo");
aggregate.DoSomething("bar");
await sut.AppendAsync(aggregate);
var container = db.GetContainer("Events");
var response = await container.GetItemLinqQueryable <dynamic>()
.CountAsync();
response.StatusCode.Should().Be(HttpStatusCode.OK);
response.Resource.Should().Be(3);
}
public async Task RehydrateAsync_should_store_events()
{
var db = await _fixture.CreateTestDatabaseAsync();
var sut = new EventsRepository <DummyAggregate, Guid>(db, _eventSerializer);
var aggregate = new DummyAggregate(Guid.NewGuid());
aggregate.DoSomething("lorem");
aggregate.DoSomething("ipsum");
await sut.AppendAsync(aggregate);
var rehydrated = await sut.RehydrateAsync(aggregate.Id);
rehydrated.Should().NotBeNull();
rehydrated.Id.Should().Be(aggregate.Id);
rehydrated.Events.Should().BeEmpty();
rehydrated.WhatHappened.Should().HaveCount(3)
.And.Contain("created")
.And.Contain("lorem")
.And.Contain("ipsum");
}
public void should_store_events_if_they_not_conclict() {
var storage = Mock.Create<IEventStorage>();
var id = Guid.Empty;
Mock
.Arrange(() => storage.GetEventsForAggregate(id, serializer_, 1))
.Returns(new List<Event> {
new Modified()
});
Mock
.Arrange(() => storage
.SaveEvents(Arg.IsAny<Guid>(), Arg.IsAny<ICollection<Event>>(), 1,
serializer_))
.Throws(new WrongExpectedVersionException(string.Empty));
var repository = new Repository<DummyAggregate>(storage, serializer_,
AggregateFactories.FromFunc(guid => new DummyAggregate(guid)),
ConflictEvaluators.FromFunc((@event, event1) => false));
var aggregate = new DummyAggregate(Guid.Empty);
Assert.That(() => repository.Save(aggregate, 1), Throws.Nothing);
}
public async Task AppendAsync_should_store_events()
{
var connStr = new Uri(_fixture.ConnectionString);
var logger = NSubstitute.Substitute.For <ILogger <EventStoreConnectionWrapper> >();
using var conn = new EventStoreConnectionWrapper(connStr, logger);
var serializer = NSubstitute.Substitute.For <IEventSerializer>();
var sut = new EventsRepository <DummyAggregate, Guid>(conn, serializer);
var aggregate = new DummyAggregate(Guid.NewGuid());
aggregate.DoSomething("foo");
aggregate.DoSomething("bar");
await sut.AppendAsync(aggregate);
var rehydrated = await sut.RehydrateAsync(aggregate.Id);
rehydrated.Should().NotBeNull();
rehydrated.Version.Should().Be(3);
}
