public async Task GivenAnIdAndVersionThatExistsThenTheAggregateIsReturnedAsync()
{
var aggregate = new SerializableAggregateRoot();
_ = repository
.Setup(repo => repo.GetAsync(
It.Is <Guid>(id => id == aggregate.Id),
It.IsAny <CancellationToken?>(),
It.Is <SignedVersion>(v => v == aggregate.Version)))
.ReturnsAsync(aggregate);
AggregateRoot value = await repository.Object.GetAsync(
context,
aggregate.Id,
version : aggregate.Version);
repository.Verify(
repo => repo.GetAsync(
It.IsAny <Guid>(),
It.IsAny <CancellationToken?>(),
It.IsAny <SignedVersion>()),
Times.Once);
Assert.Equal(aggregate, value);
}
public void GivenANewAggregateAndNoCurrentAggregateThenNoExceptionIsThrown()
{
var proposed = new SerializableAggregateRoot();
SerializableAggregateRoot?current = default;
AggregateDoesNotConflict(proposed, current);
}
public WhenPublishAsyncIsCalled()
{
aggregate = new SerializableAggregateRoot();
context = new SerializableMessage();
store = new Mock <IStore <AtomicUnit, Guid> >();
bus = new PersistentBus(store.Object);
}
public void GivenAnAggregateThenTheVersionOfThatAggregateIsReturned()
{
var aggregate = new SerializableAggregateRoot();
SignedVersion version = aggregate;
Assert.Equal(aggregate.Version, version);
}
public void GivenADifferentVersionThenTheResponseIsNegative()
{
SignedVersion version = aggregate.Version;
var other = new SerializableAggregateRoot();
Assert.False(other.Version.IsNext(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 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 async Task GivenAVersionedReferenceThatDoesNotExistsThenAnAggregateVersionNotFoundExceptionIsThrownAsync()
{
_ = repository
.Setup(repo => repo.GetAsync(
It.IsAny <Guid>(),
It.IsAny <CancellationToken?>(),
It.IsAny <SignedVersion>()))
.ReturnsAsync(default(SerializableAggregateRoot));
var aggregate = new SerializableAggregateRoot();
var reference = Reference.Create(aggregate);
AggregateVersionNotFoundException <SerializableAggregateRoot> exception =
await Assert.ThrowsAsync <AggregateVersionNotFoundException <SerializableAggregateRoot> >(
() => 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(reference, exception.Aggregate);
Assert.Equal(context, exception.Context);
}
public void GivenAnAggregateThenTheIdForThatAggregateIsReturned()
{
var aggregate = new SerializableAggregateRoot();
Guid id = aggregate;
Assert.Equal(aggregate.Id, id);
}
public async Task GivenANewAggregateWhenNoExistingMemberWithTheSameIdExistsThenTheSavingEventIsRaisedPriorToTheVersionIncrementAsync()
{
var expectedAggregate = new SerializableAggregateRoot();
bool wasInvoked = false;
IRepository <SerializableAggregateRoot> expectedRepository =
Create <SerializableAggregateRoot>();
Task Aggregate_Saving(
IRepository <SerializableAggregateRoot> actualRepository,
AggregateSavingAsyncEventArgs <SerializableAggregateRoot> e)
{
Assert.Equal(expectedRepository, actualRepository);
Assert.Equal(expectedAggregate, e.Aggregate);
Assert.Same(expectedAggregate, e.Aggregate);
Assert.True(e.Aggregate.Version.IsNew);
return(Task.FromResult(wasInvoked = true));
}
expectedRepository.AggregateSaving += Aggregate_Saving;
await expectedRepository.SaveAsync(expectedAggregate);
Assert.True(wasInvoked);
}
public async Task GivenAReferenceThatExistsThenTheLatestAggregateIsReturnedAsync()
{
var aggregateId = Guid.NewGuid();
var firstAggregate = new Mock <SerializableAggregateRoot>(aggregateId);
var secondAggregate = new Mock <SerializableAggregateRoot>(aggregateId);
var reference = Reference <SerializableAggregateRoot> .Create(aggregateId);
_ = repository
.Setup(repo => repo.GetAsync(
It.Is <Guid>(id => id == aggregateId),
It.IsAny <CancellationToken?>(),
It.Is <SignedVersion>(v => v == default)))
.ReturnsAsync(secondAggregate.Object);
SerializableAggregateRoot value = await reference.RetrieveAsync(context, repository.Object);
repository.Verify(
repo => repo.GetAsync(
It.IsAny <Guid>(),
It.IsAny <CancellationToken?>(),
It.IsAny <SignedVersion>()),
Times.Once);
Assert.Equal(secondAggregate.Object, value);
}
public void GivenAnAggregateThenAReferenceForThatAggregateIsReturned()
{
var aggregate = new SerializableAggregateRoot();
Reference reference = aggregate;
Assert.True(reference.IsMatch(aggregate));
}
public void GivenADifferentVersionWhenFooterAndNumberAreUsedThenTheResponseIsNegative()
{
SignedVersion version = aggregate.Version;
var other = new SerializableAggregateRoot();
Assert.False(other.Version.IsNext(version.Footer, version.Number));
}
public void GivenAnVersionThenTheVersionSignatureIsReturned()
{
var aggregate = new SerializableAggregateRoot();
SignedVersion version = aggregate.Version;
Guid signature = version;
Assert.Equal(version.Signature, signature);
}
public void GivenAnIdThenTheIdIsPropagated()
{
var expectedId = Guid.NewGuid();
var aggregate = new SerializableAggregateRoot(expectedId);
Assert.Equal(expectedId, aggregate.Id);
Assert.True(aggregate.HasUncommittedChanges);
}
public void GivenAnAggregateAndNoInvariantsThenNoExceptionIsThrown()
{
var context = new SerializableMessage();
var request = new TestableRequest(context);
var aggregate = new SerializableAggregateRoot();
request.Satisfies(aggregate);
}
public void GivenAnAggregateThenAnInstanceIsReturnedWithTheAggregateReferenceSet()
{
var aggregate = new SerializableAggregateRoot();
var instance = new SerializableProjection <SerializableAggregateRoot>(aggregate);
var expected = aggregate.ToReference();
Assert.Equal(expected, instance.Aggregate);
}
public void GivenAnAggregateThenAnInstanceIsCreated()
{
var aggregate = new SerializableAggregateRoot();
var @event = new AggregateSavedAsyncEventArgs <SerializableAggregateRoot>(aggregate);
Assert.Equal(aggregate, @event.Aggregate);
Assert.Same(aggregate, @event.Aggregate);
}
public void GivenAMatchingReferenceThenTrueIsReturned()
{
var aggregateId = Guid.NewGuid();
var aggregate = new SerializableAggregateRoot(aggregateId);
Reference reference = Create <SerializableAggregateRoot>(aggregateId);
Assert.True(condition: reference.IsMatch(aggregate));
}
public void GivenAProjectionWhenCastToAnUntypedReferenceThenTheUntypedReferenceForItsAggregateIsReturned()
{
var aggregate = new SerializableAggregateRoot();
var projection = new SerializableProjection <SerializableAggregateRoot>(aggregate);
Reference reference = projection;
Assert.True(reference.IsMatch(aggregate));
}
public void GivenAnVersionThenTheVersionNumberIsReturned()
{
var aggregate = new SerializableAggregateRoot();
SignedVersion version = aggregate.Version;
ulong number = version;
Assert.Equal(version.Number, number);
}
public void GivenAVersionedReferenceThatDoesNotExistsThenNoEntryIsReturned()
{
var aggregate = new SerializableAggregateRoot();
var reference = aggregate.ToReference();
bool exists = Dictionary.TryGetValue(reference, out _);
Assert.False(exists);
}
public void GivenAMatchingProjectionThenANegativeResponseIsReturned()
{
var aggregate = new SerializableAggregateRoot();
var first = new SerializableProjection <SerializableAggregateRoot>(aggregate);
var second = new SerializableProjection <SerializableAggregateRoot>(aggregate);
Assert.False(first != second);
Assert.False(second != first);
}
public void GivenATypedReferenceThenTheIdOfThatReferenceIsReturned()
{
var aggregate = new SerializableAggregateRoot();
var reference = aggregate.ToReference();
Type type = reference;
Assert.Equal(reference.Type, type);
Assert.Equal(typeof(SerializableAggregateRoot), type);
}
private static DomainEvent[] CreateEvents()
{
var aggregate = new SerializableAggregateRoot();
var context = new SerializableMessage();
var firstEvent = new SerializableDomainEvent <SerializableAggregateRoot>(context, aggregate);
var secondEvent = new SerializableDomainEvent <SerializableAggregateRoot>(context, aggregate);
return(new[] { firstEvent, secondEvent });
}
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 GivenAMatchingProjectionThenAPositiveResponseIsReturned()
{
var aggregate = new SerializableAggregateRoot();
var first = new SerializableProjection <SerializableAggregateRoot>(aggregate);
var second = new SerializableProjection <SerializableAggregateRoot>(aggregate);
Assert.True(first == second);
Assert.True(first.Equals(second));
Assert.True(second == first);
}
public void GivenAUnTypedReferenceThenTheReferenceIsReturned()
{
var aggregate = new SerializableAggregateRoot();
Reference original = aggregate.ToReference();
_ = info.TryAddReference(nameof(original), original);
Reference retrieved = info.TryGetReference(nameof(original));
Assert.Equal(original, retrieved);
}
public void GiveEventsFromTwoAggregatesThenAnArgumentExceptionIsThrown()
{
var firstAggregate = new SerializableAggregateRoot();
var secondAggregate = new SerializableAggregateRoot();
var context = new SerializableMessage();
var firstEvent = new SerializableDomainEvent <SerializableAggregateRoot>(context, firstAggregate);
var secondEvent = new SerializableDomainEvent <SerializableAggregateRoot>(context, secondAggregate);
_ = Assert.Throws <ArgumentException>(() => new AtomicUnit(new[] { firstEvent, secondEvent }));
}
public void GivenTheAggregateAndTheEventAggregateThenAnInstanceIsReturnedWithAllPropertiesSet()
{
var subject = new SerializableAggregateRoot();
var aggregate = subject.ToReference();
var eventAggregate = subject.ToReference();
var instance = new AggregateEventMismatchException(aggregate, eventAggregate);
Assert.Equal(aggregate, instance.Aggregate);
Assert.Equal(eventAggregate, instance.EventAggregate);
}
