public void GivenANewAggregateAndAnExistingAggregateThatConflictsThenAnAggregateConflictDetectedExceptionIsThrown()
{
var current = new SerializableAggregateRoot();
var proposed = new SerializableAggregateRoot();
AggregateConflictDetectedException <SerializableAggregateRoot> exception =
Assert.Throws <AggregateConflictDetectedException <SerializableAggregateRoot> >(
() => AggregateDoesNotConflict(proposed, current));
Assert.Equal(proposed.Version, exception.Received);
Assert.Equal(current.Version, exception.Persisted);
}
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 GivenAnAggregateIdAReceivedVersionAndAPersistedTheAnInstanceIsReturnedWithAllPropertiesSet()
{
var subject = new SerializableAggregateRoot();
Guid aggregateId = subject.Id;
SignedVersion received = subject.Version;
SignedVersion persisted = subject.Version.Next();
var instance = new AggregateConflictDetectedException <SerializableAggregateRoot>(aggregateId, persisted, received);
Assert.Equal(aggregateId, instance.Aggregate.Id);
Assert.Equal(received, instance.Received);
Assert.Equal(persisted, instance.Persisted);
}
public async Task GivenANonNewAnAggregateWhenNoExistingMemberWithTheSameIdExistsThenAnAggregateConflictDetectedExceptionIsThrownAsync()
{
var aggregate = new SerializableAggregateRoot();
aggregate.MarkChangesAsCommitted();
aggregate.Set();
IRepository <SerializableAggregateRoot> repository =
Create <SerializableAggregateRoot>();
AggregateConflictDetectedException <SerializableAggregateRoot> exception =
await Assert.ThrowsAsync <AggregateConflictDetectedException <SerializableAggregateRoot> >(
() => repository.SaveAsync(aggregate));
Assert.Equal(aggregate.Id, exception.Aggregate.Id);
Assert.Equal(SignedVersion.Empty, exception.Persisted);
}
public async Task GivenANewAggregateWhenAnExistingMemberWithTheSameIdExistsThenAnAggregateConflictDetectedExceptionIsThrownAsync()
{
var saved = new SerializableAggregateRoot();
var pending = new SerializableAggregateRoot(saved.Id);
IRepository <SerializableAggregateRoot> repository =
Create <SerializableAggregateRoot>();
await repository.SaveAsync(saved);
AggregateConflictDetectedException <SerializableAggregateRoot> exception =
await Assert.ThrowsAsync <AggregateConflictDetectedException <SerializableAggregateRoot> >(
() => repository.SaveAsync(pending));
Assert.Equal(saved.Id, exception.Aggregate.Id);
Assert.Equal(saved.Version, exception.Persisted);
}
public void GivenAnInstanceThenAllPropertiesAreSerialized()
{
var subject = new SerializableEventCentricAggregateRoot();
var aggregate = subject.ToReference();
var original = new AggregateConflictDetectedException <SerializableEventCentricAggregateRoot>(
aggregate,
subject.Version,
subject.Version);
AggregateConflictDetectedException <SerializableEventCentricAggregateRoot> deserialized = original.Clone();
Assert.NotSame(original, deserialized);
Assert.Equal(original.Aggregate, deserialized.Aggregate);
Assert.Equal(original.Received, deserialized.Received);
Assert.Equal(original.Persisted, deserialized.Persisted);
}
public async Task GivenAnAggregateWhenAnExistingMemberHasALowerVersionThenAnAggregateConflictDetectedExceptionIsThrownAsync()
{
var saved = new SerializableAggregateRoot();
IRepository <SerializableAggregateRoot> repository =
Create <SerializableAggregateRoot>();
await repository.SaveAsync(saved);
SerializableAggregateRoot pending = saved.Clone();
pending.Set();
pending.MarkChangesAsCommitted();
pending.Set();
pending.MarkChangesAsCommitted();
AggregateConflictDetectedException <SerializableAggregateRoot> exception =
await Assert.ThrowsAsync <AggregateConflictDetectedException <SerializableAggregateRoot> >(
() => repository.SaveAsync(pending));
Assert.Equal(saved.Id, exception.Aggregate.Id);
Assert.Equal(saved.Version, exception.Persisted);
}
