public void GivenAVersionThenTheHeaderOfTheNextVersionIsTheFooterOfThePreviousVersion() { SignedVersion version = aggregate.Version; SignedVersion next = version.Next(); Assert.Equal(version.Footer, next.Header); }
public void GivenAVersionThenTheHeaderOfTheNextVersionNumberIsOneHigherThanThePreviousVersion() { SignedVersion version = aggregate.Version; SignedVersion next = version.Next(); Assert.True(next.Number - version.Number == 1); }
public void GivenAVersionThenTheNextVersionIsReturned() { SignedVersion version = aggregate.Version; SignedVersion next = version.Next(); Assert.True(next.IsNext(version)); }
public async Task GivenAVersionThatIsNotTheCurrentVersionThenANullValueIsReturnedAsync() { var aggregate = new SerializableEventCentricAggregateRoot(); SignedVersion expectedFirst = aggregate.Version; IRepository <SerializableEventCentricAggregateRoot> repository = Create <SerializableEventCentricAggregateRoot>(); await repository.SaveAsync(aggregate); var context = new SerializableMessage(); aggregate.Set(new SetRequest(context, Guid.NewGuid())); SignedVersion expectedSecond = aggregate.Version; await repository.SaveAsync(aggregate); var other = new SerializableEventCentricAggregateRoot(); await repository.SaveAsync(other); SerializableEventCentricAggregateRoot?actualFirst = await repository.GetAsync(aggregate.Id, version : expectedFirst); SerializableEventCentricAggregateRoot?actualSecond = await repository.GetAsync(aggregate.Id, version : expectedSecond); Assert.Null(actualFirst); Assert.NotNull(actualSecond); Assert.NotSame(expectedSecond, actualSecond); Assert.Equal(aggregate.Id, actualSecond !.Id); Assert.Equal(expectedSecond, actualSecond.Version); }
private protected AggregateConflictDetectedException(Reference aggregate, SignedVersion received) : base(FormatMessage(aggregate, received)) { Aggregate = aggregate; Persisted = SignedVersion.Empty; Received = received; }
public void GivenAnAggregateThenTheVersionOfThatAggregateIsReturned() { var aggregate = new SerializableAggregateRoot(); SignedVersion version = aggregate; Assert.Equal(aggregate.Version, version); }
public async Task GivenAVersionedReferenceAndARequestForASpecificVersionWhenMoreThanOneVersionExistsThenTheRequestedVersionIsReturnedAsync() { var aggregate = new SerializableAggregateRoot(); SignedVersion firstVersion = aggregate.Version; var reference = Reference.Create(aggregate); aggregate.MarkChangesAsCommitted(); var context = new SerializableMessage(); aggregate.Set(); _ = repository .Setup(repo => repo.GetAsync( It.Is <Guid>(id => id == aggregate.Id), It.IsAny <CancellationToken?>(), It.Is <SignedVersion>(v => v == firstVersion))) .ReturnsAsync(aggregate); AggregateRoot value = await repository.Object.GetAsync(context, reference, latest : false); repository.Verify( repo => repo.GetAsync( It.IsAny <Guid>(), It.IsAny <CancellationToken?>(), It.IsAny <SignedVersion>()), Times.Once); Assert.Equal(aggregate, value); }
public void GivenTheNextVersionThenTheResponseIsPositive() { SignedVersion version = aggregate.Version; SignedVersion next = version.Next(); Assert.True(next.IsNext(version)); }
protected virtual async Task <bool> EventsAreNonConflictingAsync( Reference aggregate, IEnumerable <DomainEvent> events, CancellationToken?cancellationToken = default) { IEnumerable <SignedVersion> versions = events .Select(@event => @event.Aggregate.Version) .Distinct(); SignedVersion previous = versions.First(); foreach (SignedVersion next in versions.Skip(1)) { if (!next.IsNext(previous)) { await OnAggregateConflictDetectedAsync( aggregate, events, next, previous, cancellationToken : cancellationToken) .ConfigureAwait(false); return(false); } } return(true); }
private protected AggregateConflictDetectedException(Reference aggregate, SignedVersion persisted, SignedVersion received) : base(FormatMessage(aggregate, received, persisted: persisted, persistedRequired: true)) { Aggregate = aggregate; Persisted = persisted; Received = received; }
public void GivenADifferentVersionWhenFooterAndNumberAreUsedThenTheResponseIsNegative() { SignedVersion version = aggregate.Version; var other = new SerializableAggregateRoot(); Assert.False(other.Version.IsNext(version.Footer, version.Number)); }
public void GivenThePreviousVersionThenTheResponseIsNegative() { SignedVersion version = aggregate.Version; SignedVersion next = version.Next(); Assert.False(version.IsNext(next)); }
internal AggregateConflictDetectedAsyncEventArgs( Reference aggregate, IEnumerable <DomainEvent> events, SignedVersion next, SignedVersion previous, CancellationToken?cancellationToken = default) : base(cancellationToken: cancellationToken) { Aggregate = ReferenceIsNotEmpty( aggregate, nameof(aggregate), AggregateConflictDetectedEventArgsAggregateRequired); Events = ArgumentNotEmpty( events, nameof(events), AggregateConflictDetectedEventArgsEventsRequired); Next = ArgumentNotNull( next, nameof(next), AggregateConflictDetectedEventArgsNextRequired); Previous = ArgumentNotNull( previous, nameof(previous), AggregateConflictDetectedEventArgsPreviousRequired); }
public void GivenTheNextNextVersionWhenFooterAndNumberAreUsedThenTheResponseIsNegative() { SignedVersion version = aggregate.Version; SignedVersion next = version.Next().Next(); Assert.False(next.IsNext(version.Footer, version.Number)); }
public void GivenAnVersionThenAGuidMatchingThatVersionIsReturned() { var aggregate = new SerializableAggregateRoot(); SignedVersion version = aggregate.Version.Next(); var expected = new Guid(new[] { version.Header.ElementAt(0), version.Header.ElementAt(1), version.Header.ElementAt(2), version.Header.ElementAt(3), version.Header.ElementAt(4), version.Header.ElementAt(5), version.Header.ElementAt(6), version.Header.ElementAt(7), version.Footer.ElementAt(0), version.Footer.ElementAt(1), version.Footer.ElementAt(2), version.Footer.ElementAt(3), version.Footer.ElementAt(4), version.Footer.ElementAt(5), version.Footer.ElementAt(6), version.Footer.ElementAt(7), }); var actual = version.ToGuid(); Assert.Equal(expected, actual); }
public void GivenADifferentVersionThenTheResponseIsNegative() { SignedVersion version = aggregate.Version; var other = new SerializableAggregateRoot(); Assert.False(other.Version.IsNext(version)); }
public void GivenNoAggregateThenAnEmptyVersionIsReturned() { SerializableAggregateRoot?aggregate = default; SignedVersion version = aggregate; Assert.Equal(SignedVersion.Empty, version); }
public void GivenAnEmptyReferenceThenAnEmptyVersionIsReturned() { Reference reference = Reference <SerializableAggregateRoot> .Empty; SignedVersion version = reference; Assert.Equal(reference.Version, version); Assert.True(version.IsEmpty); }
public void GivenAnEmptyVersionThenAnEmptyGuidIsReturned() { SignedVersion version = SignedVersion.Empty; Guid signature = version; Assert.Equal(version.Signature, signature); Assert.Equal(Guid.Empty, signature); }
public void GivenAnVersionThenTheVersionSignatureIsReturned() { var aggregate = new SerializableAggregateRoot(); SignedVersion version = aggregate.Version; Guid signature = version; Assert.Equal(version.Signature, signature); }
public void GivenANullReferenceThenAnEmptyVersionIsReturned() { Reference? reference = default; SignedVersion version = reference; Assert.Equal(SignedVersion.Empty, version); Assert.True(version.IsEmpty); }
public void GivenAnEmptyVersionThenTheMinumumNumberIsReturned() { SignedVersion version = SignedVersion.Empty; ulong number = version; Assert.Equal(version.Number, number); Assert.Equal(ulong.MinValue, number); }
protected virtual IEnumerable <DomainEvent> RemovePreviousVersions( IEnumerable <DomainEvent> events, SignedVersion version) { return(events .Where(@event => @event.Aggregate.Version.CompareTo(version) > 0) .ToArray()); }
public void GivenAnVersionThenTheVersionNumberIsReturned() { var aggregate = new SerializableAggregateRoot(); SignedVersion version = aggregate.Version; ulong number = version; Assert.Equal(version.Number, number); }
public void GivenASignedVersionThenAllPropertiesArePropagated() { var aggregate = new SerializableAggregateRoot(); SignedVersion original = aggregate.Version; SignedVersion deserialized = original.Clone(); Assert.NotSame(original, deserialized); Assert.Equal(original, deserialized); }
public void GivenAnEarlierVersionThenPositiveOneIsReturned() { const int ExpectedValue = 1; SignedVersion version = aggregate.Version; int actualValue = version.CompareTo(SignedVersion.Empty); Assert.Equal(ExpectedValue, actualValue); }
public void GivenALaterVersionThenNegativeOneIsReturned() { const int ExpectedValue = -1; SignedVersion version = aggregate.Version; int actualValue = SignedVersion.Empty.CompareTo(version); Assert.Equal(ExpectedValue, actualValue); }
public void GivenAnReferenceThenTheVersionOfThatReferenceIsReturned() { var aggregate = new SerializableAggregateRoot(); var reference = aggregate.ToReference(); SignedVersion version = reference; Assert.Equal(reference.Version, version); Assert.Equal(aggregate.Version, version); Assert.False(version.IsEmpty); Assert.True(version.IsNew); }
public void GivenANullAggregateAndAReceivedVersionTheAnArgumentExceptionIsThrown() { var subject = new SerializableAggregateRoot(); Reference <SerializableAggregateRoot>?aggregate = default; SignedVersion received = subject.Version; ArgumentException exception = Assert.Throws <ArgumentException>( () => new AggregateConflictDetectedException <SerializableAggregateRoot>(aggregate !, received)); Assert.Equal(nameof(aggregate), exception.ParamName); }
public void GivenAEmptyAggregateIdAndAReceivedVersionTheAnArgumentExceptionIsThrown() { var subject = new SerializableAggregateRoot(); Guid id = Guid.Empty; SignedVersion received = subject.Version; ArgumentException exception = Assert.Throws <ArgumentException>( () => new AggregateConflictDetectedException <SerializableAggregateRoot>(id, received)); Assert.Equal(nameof(id), exception.ParamName); }