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