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);
}
public void GivenAnInstanceThenAllPropertiesAreSerialized()
{
var subject = new SerializableAggregateRoot();
Reference aggregate = subject.ToReference();
Reference eventAggregate = subject.ToReference();
var original = new AggregateEventMismatchException(aggregate, eventAggregate);
AggregateEventMismatchException deserialized = original.Clone();
Assert.NotSame(original, deserialized);
Assert.Equal(original.Aggregate, deserialized.Aggregate);
Assert.Equal(original.EventAggregate, deserialized.EventAggregate);
}
public void GivenAnAggregateThenAnInstanceIsReturnedWithTheAggregateReferenceSet()
{
var aggregate = new SerializableAggregateRoot();
var instance = new SerializableProjection <SerializableAggregateRoot>(aggregate);
var expected = aggregate.ToReference();
Assert.Equal(expected, instance.Aggregate);
}
public void GivenAVersionedReferenceThatDoesNotExistsThenNoEntryIsReturned()
{
var aggregate = new SerializableAggregateRoot();
var reference = aggregate.ToReference();
bool exists = Dictionary.TryGetValue(reference, out _);
Assert.False(exists);
}
public void GivenAMatchingReferenceThenANegativeResponseIsReturned()
{
var aggregate = new SerializableAggregateRoot();
var first = new SerializableProjection <SerializableAggregateRoot>(aggregate);
var second = aggregate.ToReference();
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);
}
public void GivenAMatchingReferenceThenAPositiveResponseIsReturned()
{
var aggregate = new SerializableAggregateRoot();
var first = new SerializableProjection <SerializableAggregateRoot>(aggregate);
var second = aggregate.ToReference();
Assert.True(first == second);
Assert.True(first.Equals(second));
Assert.True(second == first);
}
public void GivenAnAggregateAndAContextThenAnInstanceIsReturnedWithAllPropertiesSet()
{
var subject = new SerializableAggregateRoot();
var aggregate = subject.ToReference();
var context = new SerializableMessage();
var instance = new AggregateVersionNotFoundException <SerializableAggregateRoot>(context, aggregate);
Assert.Equal(aggregate, instance.Aggregate);
Assert.Equal(context, instance.Context);
}
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 GivenNoAggregateAndTheEventAggregateThenAnArgumentNullExceptionIsThrown()
{
var subject = new SerializableAggregateRoot();
Reference?aggregate = default;
var eventAggregate = subject.ToReference();
ArgumentNullException exception = Assert.Throws <ArgumentNullException>(
() => new AggregateEventMismatchException(aggregate !, eventAggregate));
Assert.Equal(nameof(aggregate), exception.ParamName);
}
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 GivenAVersionedReferenceThatDoesNotExistThenTheEntryIsAddedWithAnUnversionedReference()
{
var aggregate = new SerializableAggregateRoot();
var reference = aggregate.ToReference();
Dictionary.Add(reference, aggregate);
Assert.Contains(Dictionary.Values, element => element == aggregate);
Assert.Contains(Dictionary.Keys, element => element == reference);
Assert.DoesNotContain(Dictionary.Keys, element => element.IsVersioned);
}
public void GivenAnAggregateAndANullReceivedVersionTheAnArgumentNullExceptionIsThrown()
{
var subject = new SerializableAggregateRoot();
var aggregate = subject.ToReference();
SignedVersion?received = default;
ArgumentNullException exception = Assert.Throws <ArgumentNullException>(
() => new AggregateConflictDetectedException <SerializableAggregateRoot>(aggregate, received !));
Assert.Equal(nameof(received), exception.ParamName);
}
public void GivenAnAggregateAndANullContextThenAnArgumentNullExceptionIsThrown()
{
var subject = new SerializableAggregateRoot();
var aggregate = subject.ToReference();
Message?context = default;
ArgumentNullException exception = Assert.Throws <ArgumentNullException>(
() => new AggregateVersionNotFoundException <SerializableAggregateRoot>(context !, aggregate));
Assert.Equal(nameof(context), exception.ParamName);
}
public void GivenAnAbstractAggregateThenAReferenceWithTheSameIdTypeAndVersionIsReturned()
{
var aggregateId = Guid.NewGuid();
AggregateRoot aggregate = new SerializableAggregateRoot(aggregateId);
var reference = aggregate.ToReference();
Assert.Equal(aggregateId, reference.Id);
Assert.Equal(aggregate.Version, reference.Version);
Assert.Equal(typeof(SerializableAggregateRoot), reference.Type);
}
public void GivenAVersionedReferenceThatExistThenAPositiveResponseIsReturned()
{
var aggregate = new SerializableAggregateRoot();
var reference = aggregate.ToReference();
var item = new KeyValuePair <Reference <SerializableAggregateRoot>, SerializableAggregateRoot>(reference, aggregate);
Dictionary.Add(item);
bool exists = Dictionary.Contains(item);
Assert.True(exists);
}
public void GivenATypedUnversionedReferenceThenTheSameInstanceIsReturned()
{
var aggregate = new SerializableAggregateRoot();
var original = aggregate.ToReference(unversioned: true);
Reference unversioned = original.ToUnversioned();
Assert.Equal(original, unversioned);
Assert.Same(original, unversioned);
Assert.False(original.IsVersioned);
Assert.False(unversioned.IsVersioned);
}
public void GivenAnAggregateAndAReceivedVersionTheAnInstanceIsReturnedWithAllPropertiesSet()
{
var subject = new SerializableAggregateRoot();
var aggregate = subject.ToReference();
SignedVersion received = subject.Version;
var instance = new AggregateConflictDetectedException <SerializableAggregateRoot>(aggregate, received);
Assert.Equal(aggregate, instance.Aggregate);
Assert.Equal(received, instance.Received);
Assert.Equal(SignedVersion.Empty, instance.Persisted);
}
public void GivenAnAggregateWhenUnversionedIsTrueThenAReferenceWithTheSameIdAndTypeIsReturned()
{
var aggregateId = Guid.NewGuid();
var aggregate = new SerializableAggregateRoot(aggregateId);
var reference = aggregate.ToReference(unversioned: true);
Assert.Equal(aggregateId, reference.Id);
Assert.False(reference.IsVersioned);
Assert.NotEqual(aggregate.Version, reference.Version);
Assert.Equal(typeof(SerializableAggregateRoot), reference.Type);
}
public void GivenAnInstanceThenAllPropertiesAreSerialized()
{
var subject = new SerializableAggregateRoot();
var aggregate = subject.ToReference();
var context = new SerializableMessage();
var original = new AggregateVersionNotFoundException <SerializableAggregateRoot>(context, aggregate);
AggregateVersionNotFoundException <SerializableAggregateRoot> deserialized = original.Clone();
Assert.NotSame(original, deserialized);
Assert.Equal(original.Aggregate, deserialized.Aggregate);
Assert.Equal(original.Context, deserialized.Context);
}
public void GivenAUnTypedReferenceThenTheValueIsAddedWithAPrefixedName()
{
var aggregate = new SerializableAggregateRoot();
Reference reference = aggregate.ToReference();
bool added = info.TryAddReference(nameof(reference), reference);
IDictionary <string, object?> contents = info.ToDictionary();
_ = contents.TryGetValue(nameof(reference), out object?actual);
Assert.True(added);
Assert.NotEmpty(contents);
Assert.Equal(reference, actual);
}
protected UnversionedReferenceDictionaryTests()
{
FirstAggregate = new SerializableAggregateRoot();
SecondAggregate = new SerializableAggregateRoot();
FirstReference = FirstAggregate.ToReference();
SecondReference = SecondAggregate.Id.ToReference <SerializableAggregateRoot>(version: SecondAggregate.Version.Next());
Dictionary = new UnversionedReferenceDictionary <SerializableAggregateRoot, SerializableAggregateRoot>
{
{ FirstReference, FirstAggregate },
{ SecondReference, SecondAggregate },
};
}
public void GivenAProjectionDictionaryThenAnUnversionedIsReturned()
{
var first = new SerializableAggregateRoot();
var second = new SerializableAggregateRoot();
var versioned = new Dictionary <Reference <SerializableAggregateRoot>, SerializableProjection <SerializableAggregateRoot> >
{
{ first.ToReference(), new SerializableProjection <SerializableAggregateRoot>(first) },
{ second.ToReference(), new SerializableProjection <SerializableAggregateRoot>(second) },
};
IDictionary <Reference <SerializableAggregateRoot>, SerializableProjection <SerializableAggregateRoot> > unversioned
= versioned.ToUnversioned();
Assert.Equal(versioned.Count, unversioned.Count);
Assert.Contains(versioned, entry => unversioned.Contains(entry));
Assert.DoesNotContain(unversioned, element => element.Key.IsVersioned);
}