public async Task takes_snapshot()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
// Runs all conflicting events back through a re-hydrated entity
var resolver = new Aggregates.Internal.ResolveStronglyConflictResolver(_store.Object, _eventstore.Object, streamGen);
_stream.Setup(x => x.AddSnapshot(Moq.It.IsAny <IMemento>()));
_stream.Setup(x => x.StreamVersion).Returns(0);
_stream.Setup(x => x.CommitVersion).Returns(1);
var entity = new Entity(_stream.Object, _resolver.Object);
entity.TakeASnapshot = true;
await resolver.Resolve(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>())
.ConfigureAwait(false);
Assert.AreEqual(1, entity.Conflicts);
_stream.Verify(x => x.Add(Moq.It.IsAny <IEvent>(), Moq.It.IsAny <IDictionary <string, string> >()),
Moq.Times.Once);
_store.Verify(
x => x.WriteStream <Entity>(Moq.It.IsAny <Guid>(), Moq.It.IsAny <IEventStream>(),
Moq.It.IsAny <IDictionary <string, string> >()),
Moq.Times.Once);
_stream.Verify(x => x.AddSnapshot(Moq.It.IsAny <IMemento>()), Moq.Times.Once);
}
public void dont_catch_abandon_resolution()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
// Runs all conflicting events back through a re-hydrated entity
var resolver = new Aggregates.Internal.ResolveStronglyConflictResolver(_store.Object, _eventstore.Object, streamGen);
var entity = new Entity(_stream.Object, _resolver.Object);
_resolver.Setup(x => x.Conflict(Moq.It.IsAny <Entity>(), typeof(Event))).Throws <AbandonConflictException>();
Assert.ThrowsAsync <AbandonConflictException>(
() => resolver.Resolve(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>()));
}
public void dont_catch_abandon_resolution()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
// Runs all conflicting events back through a re-hydrated entity
var resolver = new Aggregates.Internal.ResolveStronglyConflictResolver(_snapstore.Object, _eventstore.Object, streamGen);
var entity = new FakeEntity();
(entity as IEntity <FakeState>).Instantiate(new FakeState());
entity.State.ThrowAbandon = true;
Assert.ThrowsAsync <AbandonConflictException>(
() => resolver.Resolve <FakeEntity, FakeState>(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>()));
}
public void no_route_exception()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
// Runs all conflicting events back through a re-hydrated entity
var resolver = new Aggregates.Internal.ResolveStronglyConflictResolver(_snapstore.Object, _eventstore.Object, streamGen);
_event.Setup(x => x.Event).Returns(new FakeUnknownEvent());
var entity = new FakeEntity();
(entity as IEntity <FakeState>).Instantiate(new FakeState());
Assert.ThrowsAsync <ConflictResolutionFailedException>(
() => resolver.Resolve <FakeEntity, FakeState>(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>()));
}
public async Task strong_resolve_conflict()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
// Runs all conflicting events back through a re-hydrated entity
var resolver = new Aggregates.Internal.ResolveStronglyConflictResolver(_snapstore.Object, _eventstore.Object, streamGen);
var entity = new FakeEntity();
(entity as IEntity <FakeState>).Instantiate(new FakeState());
await resolver.Resolve <FakeEntity, FakeState>(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>())
.ConfigureAwait(false);
Assert.AreEqual(1, entity.State.Conflicts);
_eventstore.Verify(x => x.WriteEvents <FakeEntity>(Moq.It.IsAny <string>(), Moq.It.IsAny <Id>(), Moq.It.IsAny <Id[]>(), Moq.It.IsAny <IFullEvent[]>(), Moq.It.IsAny <IDictionary <string, string> >(), Moq.It.IsAny <long?>()), Moq.Times.Once);
}
public async Task oob_events_not_conflict_resolved()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
_event.Setup(x => x.Descriptor.Headers[Defaults.OobHeaderKey]).Returns("test");
_event.Setup(x => x.Descriptor.StreamType).Returns(StreamTypes.OOB);
// Runs all conflicting events back through a re-hydrated entity
var resolver = new Aggregates.Internal.ResolveStronglyConflictResolver(_snapstore.Object, _eventstore.Object, streamGen);
var entity = new FakeEntity();
(entity as IEntity <FakeState>).Instantiate(new FakeState());
await resolver.Resolve <FakeEntity, FakeState>(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>())
.ConfigureAwait(false);
Assert.AreEqual(0, entity.State.Conflicts);
}
public async Task doesnt_take_snapshot()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
// Runs all conflicting events back through a re-hydrated entity
var resolver = new Aggregates.Internal.ResolveStronglyConflictResolver(_snapstore.Object, _eventstore.Object, streamGen);
var uow = new Moq.Mock <IDomainUnitOfWork>();
var entity = new FakeEntity();
(entity as IEntity <FakeState>).Instantiate(new FakeState());
(entity as INeedDomainUow).Uow = uow.Object;
entity.State.TakeASnapshot = true;
_snapstore.Setup(x => x.WriteSnapshots <FakeEntity>(Moq.It.IsAny <IState>(), Moq.It.IsAny <IDictionary <string, string> >()))
.Returns(Task.CompletedTask);
await resolver.Resolve <FakeEntity, FakeState>(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>())
.ConfigureAwait(false);
Assert.AreEqual(1, entity.State.Conflicts);
_snapstore.Verify(x => x.WriteSnapshots <FakeEntity>(Moq.It.IsAny <IState>(), Moq.It.IsAny <IDictionary <string, string> >()), Moq.Times.Never);
}
