public void Inserting_E2_after_E1_at_end_of_stream()
{
RunMigrationTest(new MigrationScenario(
Seq.OfTypes <Ec1, E1>(),
Seq.OfTypes <Ec1, E1, E2>(),
After <E1> .Insert <E2>()));
}
public void Inserting_E2_after_E1()
{
RunMigrationTest(new MigrationScenario(
Seq.OfTypes <Ec1, E1, Ef, Ef>(),
Seq.OfTypes <Ec1, E1, E2, Ef, Ef>(),
After <E1> .Insert <E2>()));
}
public void Calling_before_after_or_replace_1000_000_times_takes_less_than_60_milliseconds()
{
var before = Before <E3> .Insert <E2>().CreateSingleAggregateInstanceHandlingMigrator();
var replace = Replace <E3> .With <E2>().CreateSingleAggregateInstanceHandlingMigrator();
var after = After <E3> .Insert <E2>().CreateSingleAggregateInstanceHandlingMigrator();
var @event = new E2();
var eventModifier = new EventModifier(@event, _ => { });
var numberOfEventsToInspect = 1000000;
var maxtime = TestEnvironmentPerformance.AdjustRuntime(60.Milliseconds(), boost: 12.0);
TimeAsserter.Execute(
maxTotal: maxtime,
description: $"{nameof(before)}",
iterations: numberOfEventsToInspect,
action: () => before.MigrateEvent(@event, @eventModifier));
TimeAsserter.Execute(
maxTotal: maxtime,
description: $"{nameof(replace)}",
iterations: numberOfEventsToInspect,
action: () => replace.MigrateEvent(@event, @eventModifier));
TimeAsserter.Execute(
maxTotal: maxtime,
description: $"{nameof(after)}",
iterations: numberOfEventsToInspect,
action: () => after.MigrateEvent(@event, @eventModifier));
}
public void Inserting_E3_E4_before_E1_then_E5_before_E4_then_replace_E4_with_E6_then_replace_Ef_with_E7_then_insert_E8_after_E7()
{
RunMigrationTest(new MigrationScenario
(Seq.OfTypes <Ec1, E1, Ef>(),
Seq.OfTypes <Ec1, E6, E5, E4, E1, E7, E8>(),
Before <E1> .Insert <E3, E4>(), //Ec1, E3, E4, E1, Ef
Before <E4> .Insert <E5>(), //Ec1, E3, E5, E4, E1, Ef
Replace <E3> .With <E6>(), //Ec1, E6, E5, E4, E1, Ef
Replace <Ef> .With <E7>(), //Ec1, E6, E5, E4, E1, E7
After <E7> .Insert <E8>())); //Ec1, E6, E5, E4, E1, E7, E8
}
public void Given_Ec1_E1_before_E1_E2_after_E2_E3_throws_NonIdempotentMigrationDetectedException()
{
this.Invoking(
me =>
RunMigrationTest(
new MigrationScenario(
Seq.OfTypes <Ec1, E1>(),
Seq.OfTypes <Ec1, E2, E3, E1>(),
Before <E1> .Insert <E2>(),
After <E2> .Insert <E3>())))
.ShouldThrow <NonIdempotentMigrationDetectedException>();
}
public void Inserting_E2_After_E1_Persisting_and_then_Inserting_E3_after_E1()
{
var firstMigration = Seq.Create(After <E1> .Insert <E2>()).ToArray();
var secondMigration = Seq.Create(After <E1> .Insert <E3>()).ToArray();
IReadOnlyList <IEventMigration> migrations = new List <IEventMigration>();
using (var container = CreateContainerForEventStoreType(() => migrations, EventStoreType))
{
container.Resolve <DummyTimeSource>().UtcNow = DateTime.Parse("2001-01-01 12:00");
var id = Guid.Parse("00000000-0000-0000-0000-000000000001");
var initialAggregate = TestAggregate.FromEvents(container.Resolve <IUtcTimeTimeSource>(), id, Seq.OfTypes <Ec1, E1>());
var expectedHistoryAfterFirstMigration = TestAggregate.FromEvents(container.Resolve <IUtcTimeTimeSource>(), id, Seq.OfTypes <Ec1, E1, E2>()).History;
var expectedHistoryAfterSecondMigration = TestAggregate.FromEvents(container.Resolve <IUtcTimeTimeSource>(), id, Seq.OfTypes <Ec1, E1, E3, E2>()).History;
Func <IEventStoreSession> session = () => container.Resolve <IEventStoreSession>();
Func <IEventStore> eventStore = () => container.Resolve <IEventStore>();
container.ExecuteUnitOfWorkInIsolatedScope(() => session().Save(initialAggregate));
migrations = firstMigration;
var historyWithFirstMigrationUnPersisted = container.ExecuteUnitOfWorkInIsolatedScope(() => session().Get <TestAggregate>(id).History);
container.ExecuteUnitOfWorkInIsolatedScope(() => eventStore().PersistMigrations());
var historyAfterPersistingFirstMigration = container.ExecuteUnitOfWorkInIsolatedScope(() => session().Get <TestAggregate>(id).History);
AssertStreamsAreIdentical(expectedHistoryAfterFirstMigration, historyWithFirstMigrationUnPersisted, nameof(historyWithFirstMigrationUnPersisted));
AssertStreamsAreIdentical(expectedHistoryAfterFirstMigration, historyAfterPersistingFirstMigration, nameof(historyAfterPersistingFirstMigration));
migrations = secondMigration;
ClearEventstoreCache(container);
var historyWithSecondMigrationUnPersisted = container.ExecuteUnitOfWorkInIsolatedScope(() => session().Get <TestAggregate>(id).History);
container.ExecuteUnitOfWorkInIsolatedScope(() => eventStore().PersistMigrations());
var historyAfterPersistingSecondMigration = container.ExecuteUnitOfWorkInIsolatedScope(() => session().Get <TestAggregate>(id).History);
AssertStreamsAreIdentical(expectedHistoryAfterSecondMigration, historyWithSecondMigrationUnPersisted, nameof(historyWithSecondMigrationUnPersisted));
AssertStreamsAreIdentical(expectedHistoryAfterSecondMigration, historyAfterPersistingSecondMigration, nameof(historyAfterPersistingSecondMigration));
}
}
