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); }