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;
}
