public IEnumerable <AggregateCommit> Apply(AggregateCommit current) { if (ShouldApply(current)) { var urnRaw = Urn.Parse(Encoding.UTF8.GetString(current.AggregateRootId)); var urn = AggregateUrn.Parse(urnRaw.Value); var fooId = new FooId(urn.Id, urn.Tenant); LoadFromEventStore(fooId); aggregateMaxRevision[fooId]++; var newFooEvents = new List <IEvent>(); foreach (IEvent @event in current.Events) { if (@event.GetType() == typeof(TestCreateEventBar)) { newFooEvents.Add(new TestCreateEventFoo(fooId)); } else if (@event.GetType() == typeof(TestUpdateEventBar)) { var theEvent = @event as TestUpdateEventBar; newFooEvents.Add(new TestUpdateEventFoo(fooId, theEvent.UpdatedFieldValue)); } } var aggregateCommitFooBar = new AggregateCommit(fooId.RawId, aggregateMaxRevision[fooId], newFooEvents); yield return(aggregateCommitFooBar); } else { yield return(current); } }
public FooId <T, T1, T2, T3> Upon <T1, T2, T3>(FooId <T1> fooId1, FooId <T2> fooId2, FooId <T3> fooId3) where T1 : struct, FooId where T2 : struct, FooId where T3 : struct, FooId { return(new DependentFooId <T, T1, T2, T3>(fooId1, fooId2, fooId3)); }
public void Should_provide_a_clear_syntax_for_method_selection() { FooId <TestFeature> fooId = FooIds.Enabled <TestFeature>(); fooId.If(() => { // run if it is enabled }); fooId.Unless(() => { // run if disabled }); fooId.If(() => { /* enabled */ }, () => { /* disabled */ }); var result = fooId.Iff(() => 27, () => 42); Assert.AreEqual(27, result); var value = fooId.Iff((a, b) => a, (a, b) => b, 27, 42); Assert.AreEqual(27, value); }
public FooId <T, T1, T2, T3, T4, T5> Upon <T1, T2, T3, T4, T5>(FooId <T1> fooId1, FooId <T2> fooId2, FooId <T3> fooId3, FooId <T4> fooId4, FooId <T5> fooId5) where T1 : struct, FooId where T2 : struct, FooId where T3 : struct, FooId where T4 : struct, FooId where T5 : struct, FooId { return(new DependentFooId <T, T1, T2, T3, T4, T5>(fooId1, fooId2, fooId3, fooId4, fooId5)); }
public async Task ShouldLoadSavedEventsPerAggregate() { var aggregateAId = new FooId(); var aggregateAEvents = new List <DomainEvent> { new FooEvent(1, DateTime.Now), new FooEvent(2, DateTime.Now), new FooEvent(3, DateTime.Now) }; var aggregateBId = new FooId(); var aggregateBEvents = new List <DomainEvent> { new FooEvent(4, DateTime.Now), new FooEvent(5, DateTime.Now), new FooEvent(6, DateTime.Now) }; var meta = new Dictionary <string, string> { { "foo", "bar" }, { "client-ip", "127.0.0.1" } }; await EventStore.SaveEventsAsync( nameof(FooAggregate), aggregateAId, 0, aggregateAEvents, meta); await EventStore.SaveEventsAsync( nameof(FooAggregate), aggregateBId, 0, aggregateBEvents, meta); var events = await EventStore.LoadEventsAsync(aggregateAId); Action <Event> AssertEvent(int version, int value) => @event => { @event.Id.Should().Be((uint)value); @event.StreamId.Should().Be(aggregateAId); @event.StreamVersion.Should().Be(version); @event.StreamName.Should().Be(nameof(FooAggregate)); @event.Meta.Should().BeEquivalentTo(meta); var domainEvent = @event.DomainEvent as FooEvent; Assert.NotNull(domainEvent); domainEvent.Value.Should().Be(value); }; events .Should() .SatisfyRespectively( AssertEvent(1, 1), AssertEvent(2, 2), AssertEvent(3, 3) ); }
public void Should_allow_simple_creation_of_dependent_fooids() { FooId <A> a = FooIds.Enabled <A>(); FooId <B> b = FooIds.Enabled <B>(); ToggleFooId <C> c = FooIds.Toggle <C>(); FooId <ABC> abc = FooIds.Dependent <ABC>(x => x.Upon(a, b, c)); Assert.IsFalse(abc.Enabled); c.Enable(); Assert.IsTrue(abc.Enabled); }
public async Task ShouldThrowConcurrencyCheckException() { var fooId = new FooId(); var events = new List <DomainEvent> { new FooEvent(1, DateTime.Now), new FooEvent(2, DateTime.Now), new FooEvent(3, DateTime.Now) }; await EventStore.SaveEventsAsync( nameof(FooAggregate), fooId, 0, events, new Dictionary <string, string>()); await Assert.ThrowsAsync <EventStoreConcurrencyCheckException>(() => EventStore.SaveEventsAsync( nameof(FooAggregate), fooId, 0, events, new Dictionary <string, string>())); }
public IEnumerable <AggregateCommit> Apply(AggregateCommit current) { if (ShouldApply(current)) { var fooId = new FooId("1234", "elders"); var newFooEvents = new List <IEvent>(); foreach (IEvent @event in current.Events) { if (@event.GetType() == typeof(TestCreateEventFooBar)) { newFooEvents.Add(new TestCreateEventFoo(fooId)); } else if (@event.GetType() == typeof(TestUpdateEventFooBar)) { var theEvent = @event as TestUpdateEventFooBar; newFooEvents.Add(new TestUpdateEventFoo(fooId, theEvent.UpdatedFieldValue)); } } var aggregateCommitFoo = new AggregateCommit(fooId.RawId, current.Revision, newFooEvents); yield return(aggregateCommitFoo); var barId = new BarId("5432", "elders"); var newBarEvents = new List <IEvent>(); foreach (IEvent @event in current.Events) { if (@event.GetType() == typeof(TestCreateEventFooBar)) { newBarEvents.Add(new TestCreateEventBar(barId)); } else if (@event.GetType() == typeof(TestUpdateEventFooBar)) { var theEvent = @event as TestUpdateEventFooBar; newBarEvents.Add(new TestUpdateEventBar(barId, theEvent.UpdatedFieldValue)); } } var aggregateCommitBar = new AggregateCommit(barId.RawId, current.Revision, newFooEvents); yield return(aggregateCommitBar); } else { yield return(current); } }
public async Task ShouldLoadEventsFromOffset() { var fooId = new FooId(); var events = new List <DomainEvent> { new FooEvent(1, DateTime.Now), new FooEvent(2, DateTime.Now), new FooEvent(3, DateTime.Now), new FooEvent(4, DateTime.Now), new FooEvent(5, DateTime.Now) }; await EventStore.SaveEventsAsync( nameof(FooAggregate), fooId, 0, events, new Dictionary <string, string>()); var loadedEvents = await EventStore.LoadEventsAsync(typeof(FooAggregate), 2, 2); loadedEvents .Should() .SatisfyRespectively( @event => { @event.Offset.Should().Be(3); var e = @event.Event as FooEvent; e.Value.Should().Be(3); e.CreatedAt.Should().BeSameDateAs(DateTime.Today); }, @event => { @event.Offset.Should().Be(4); var e = @event.Event as FooEvent; e.Value.Should().Be(4); e.CreatedAt.Should().BeSameDateAs(DateTime.Today); } ); }
public Floo(FooId <T1> fooId, bool enabled) : this() { _fooId = fooId; _enabled = enabled; }
public ConditionalClass(FooId <UseNewMethod> useNewMethod) { _useNewMethod = useNewMethod; }
public FooId <T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Upon <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(FooId <T1> fooId1, FooId <T2> fooId2, FooId <T3> fooId3, FooId <T4> fooId4, FooId <T5> fooId5, FooId <T6> fooId6, FooId <T7> fooId7, FooId <T8> fooId8, FooId <T9> fooId9, FooId <T10> fooId10) where T1 : struct, FooId where T2 : struct, FooId where T3 : struct, FooId where T4 : struct, FooId where T5 : struct, FooId where T6 : struct, FooId where T7 : struct, FooId where T8 : struct, FooId where T9 : struct, FooId where T10 : struct, FooId { return(new DependentFooId <T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(fooId1, fooId2, fooId3, fooId4, fooId5, fooId6, fooId7, fooId8, fooId9, fooId10)); }
public FooId <T, T1> Upon <T1>(FooId <T1> fooId1) where T1 : struct, FooId { return(new DependentFooId <T, T1>(fooId1)); }
public FooId <T, T1, T2, T3, T4, T5, T6, T7> Upon <T1, T2, T3, T4, T5, T6, T7>(FooId <T1> fooId1, FooId <T2> fooId2, FooId <T3> fooId3, FooId <T4> fooId4, FooId <T5> fooId5, FooId <T6> fooId6, FooId <T7> fooId7) where T1 : struct, FooId where T2 : struct, FooId where T3 : struct, FooId where T4 : struct, FooId where T5 : struct, FooId where T6 : struct, FooId where T7 : struct, FooId { return(new DependentFooId <T, T1, T2, T3, T4, T5, T6, T7>(fooId1, fooId2, fooId3, fooId4, fooId5, fooId6, fooId7)); }
public TestAggregateRootFoo(FooId id) { var @event = new TestCreateEventFoo(id); Apply(@event); }
public FooId <T, T1, T2> Upon <T1, T2>(FooId <T1> fooId1, FooId <T2> fooId2) where T1 : struct, FooId where T2 : struct, FooId { return(new DependentFooId <T, T1, T2>(fooId1, fooId2)); }
public DependentFooId(FooId <T1> fooId1) { _fooId1 = fooId1; }