private static Task PerformCoordinatedReconcileAsync( EventCentricAggregateRoot aggregate, IAggregateReconciliationProxy proxy, CancellationToken?cancellationToken) { return(proxy.OverwriteAsync(aggregate, cancellationToken: cancellationToken)); }
public virtual Task SaveAsync( EventCentricAggregateRoot aggregate, CancellationToken?cancellationToken = default) { PerformSave(aggregate); return(Task.CompletedTask); }
protected override void PerformSave(EventCentricAggregateRoot aggregate) { if (save is null) { throw new NotImplementedException(); } save(aggregate); }
private Task ReconcileAsync( EventCentricAggregateRoot aggregate, IAggregateReconciliationProxy proxy, CancellationToken?cancellationToken) { return(aggregate.CoordinateAsync( () => PerformCoordinatedReconcileAsync(aggregate, proxy, cancellationToken), cancellationToken: cancellationToken, timeout: timeout)); }
public async Task GivenEventsThenAnAggregateHydratedWithThoseEventsIsReturnedAsync() { var expected = new SerializableEventCentricAggregateRoot(); var context = new SerializableMessage(); expected.Set(new SetRequest(context, Guid.NewGuid())); expected.Set(new SetRequest(context, Guid.NewGuid())); IEnumerable <DomainEvent> events = expected.GetUncommittedChanges(); expected.MarkChangesAsCommitted(); var reconciler = new TestableDefaultAggregateFactory(); EventCentricAggregateRoot actual = await reconciler.CreateAsync(events); Assert.NotSame(expected, actual); Assert.Equal(expected, actual); }
protected virtual async Task ApplyAsync( EventCentricAggregateRoot aggregate, IEnumerable <DomainEvent> events, IAggregateReconciliationProxy proxy, Reference reference, CancellationToken?cancellationToken = default) { if (events.Any()) { try { aggregate.LoadFromHistory(events); await proxy .SaveAsync(aggregate, cancellationToken : cancellationToken) .ConfigureAwait(false); await OnAggregateReconciledAsync(reference, events, cancellationToken : cancellationToken) .ConfigureAwait(false); } catch (AggregateHistoryInvalidForStateException invalid) { await OnAggregateConflictDetectedAsync( invalid.Aggregate, events, invalid.StartingVersion, invalid.Aggregate.Version, cancellationToken : cancellationToken) .ConfigureAwait(false); } catch (AggregateConflictDetectedException conflict) { await OnAggregateConflictDetectedAsync( reference, events, conflict.Received, conflict.Persisted, cancellationToken : cancellationToken) .ConfigureAwait(false); } } }
public async Task <EventCentricAggregateRoot> CreateAsync( IEnumerable <DomainEvent> events, CancellationToken?cancellationToken = default) { if (!events.SafeAny()) { throw new DomainEventsMissingException(); } Reference aggregate = events.First().Aggregate; EventCentricAggregateRoot instance = await CreateAsync( aggregate, cancellationToken : cancellationToken) .ConfigureAwait(false); instance.LoadFromHistory(events); return(instance); }
protected abstract void PerformSave(EventCentricAggregateRoot aggregate);
protected abstract void PerformOverwrite(EventCentricAggregateRoot aggregate);
public virtual Task ReconcileAsync( EventCentricAggregateRoot aggregate, CancellationToken?cancellationToken = default) { return(ReconcileAsync(new[] { aggregate }, cancellationToken: cancellationToken)); }
public async Task GivenAStreamThenTheSnapshotContainsTheAggregatesThatComprizeThatStreamAsync() { SerializableEventCentricAggregateRoot expected = CreateAggregate(out IEnumerable <DomainEvent> events); var other = new SerializableEventCentricAggregateRoot(expected.Id); _ = factory .Setup(factory => factory.CreateAsync( It.IsAny <Reference>(), It.IsAny <CancellationToken?>())) .ReturnsAsync(other); _ = proxy .Setup(proxy => proxy.GetAsync( It.IsAny <Reference>(), It.IsAny <CancellationToken?>())) .ReturnsAsync(default(EventCentricAggregateRoot) !); _ = proxy .Setup(proxy => proxy.GetAllAsync(It.IsAny <CancellationToken?>())) .ReturnsAsync(new[] { other }); _ = store .Setup(store => store.ReadAsync( It.Is <ulong>(lastIndex => lastIndex == ulong.MinValue), It.IsAny <CancellationToken?>(), It.IsAny <ushort>())) .ReturnsAsync(new[] { new SequencedEvents(1, events.ToArray()) }); _ = store .Setup(store => store.ReadAsync( It.Is <ulong>(lastIndex => lastIndex > ulong.MinValue), It.IsAny <CancellationToken?>(), It.IsAny <ushort>())) .ReturnsAsync(Enumerable.Empty <SequencedEvents>()); var instance = new DefaultSnapshotProvider <SequencedEvents>( store.Object, factory.Object, () => type => proxy.Object); ISnapshot?snapshot = await instance.GenerateAsync(); Assert.NotNull(snapshot); EventCentricAggregateRoot actual = Assert.Single(snapshot !.Aggregates); Assert.Equal(expected, actual); factory.Verify( factory => factory.CreateAsync( It.IsAny <Reference>(), It.IsAny <CancellationToken?>()), times: Times.Once); factory.Verify( factory => factory.CreateAsync( It.Is <Reference>(reference => reference.Id == expected.Id), It.IsAny <CancellationToken?>()), times: Times.Once); proxy.Verify( proxy => proxy.GetAsync( It.IsAny <Reference>(), It.IsAny <CancellationToken?>()), times: Times.Once); proxy.Verify( proxy => proxy.GetAllAsync(It.IsAny <CancellationToken?>()), times: Times.Once); }