internal EventStoreConfigurator RegisterInMemoryEventStore(IContainer container)
{
var eventStore = new InMemoryEventStore(EventStoreSettings.GetDefault());
container.Configure(config => config.For<IEventStore>().Singleton().Use(eventStore));
return this;
}
public void Setup()
{
_eventStore = new InMemoryEventStore();
_aggregates = Aggregates.CreateWith(_eventStore);
_eventHandler = new TestEventHandler();
}
protected override void DoSetUp()
{
_stuffThatHappened = new List<string>();
_resetEvent = new AutoResetEvent(false);
_eventStore = new InMemoryEventStore(new JsonDomainEventSerializer());
var topicName = TestAzureHelper.GetTopicName("cirqus");
var subscriptionName = TestAzureHelper.GetSubscriptionName("testsubscriber");
_sender = new AzureServiceBusEventDispatcherSender(TestAzureHelper.ConnectionString, topicName);
_receiver = new AzureServiceBusEventDispatcherReceiver(TestAzureHelper.ConnectionString, this, _eventStore, topicName, subscriptionName);
}
public void Test()
{
var newMessages = new List<object>();
var bus = new MessageBus();
bus.RegisterHandler<object>(newMessages.Add);
var eventStore = new InMemoryEventStore(bus, GivenTheseEvents());
var repository = new DomainRepository(eventStore);
RegisterHandler(bus, repository);
bus.Handle(WhenThisHappens());
var expected = TheseEventsShouldOccur();
Assert.AreEqual(expected.Count(), newMessages.Count);
}
public async Task Should_not_retrieve_the_aggregate_from_tracking_after_commit()
{
var eventStore = new InMemoryEventStore();
var session = _sessionFactory(eventStore, _eventPublisherMock.Object);
var stubAggregate1 = StubAggregate.Create("Walter White");
session.Add(stubAggregate1);
await session.CommitAsync();
var stubAggregate2 = await session.GetByIdAsync <StubAggregate>(stubAggregate1.AggregateId);
stubAggregate1.Should().NotBeSameAs(stubAggregate2);
}
public void Save_should_throw_ArgumentNullException_on_null_parameter()
{
var eventDispatcherMockBuilder = new Mock <IEventDispatcher>();
var sut = new InMemoryEventStore(eventDispatcherMockBuilder.Object);
Executing.This(() => sut.Save(null))
.Should()
.Throw <ArgumentNullException>()
.And
.ValueOf
.ParamName
.Should()
.Be
.EqualTo("event");
}
public void GivenEmptyEventStore_WhenAddingEventsInBulk_ThenStoreShouldContainThoseEvents()
{
// Arrange
IEventStore store = new InMemoryEventStore();
var user = new User();
user.Register();
user.ChangePassword("newpassword");
// Act
store.Store(user.Id, user.GetUncommittedEvents());
// Assert
CollectionAssert.IsNotEmpty(((InMemoryEventStore)store).Events);
CollectionAssert.AreEqual(user.GetUncommittedEvents(), ((InMemoryEventStore)store).Events);
}
public void GivenEmptyEventStore_WhenAddingEventsOneAtATime_ThenStoreShouldContainThoseEvents()
{
// Arrange
IEventStore store = new InMemoryEventStore(new ConsoleLogger());
var userId = Guid.NewGuid();
var userRegistered = new UserRegistered(userId);
// Act
store.Save <User>(userId.ToString(), 0, new[] { userRegistered });
// Assert
var allEvents = ((InMemoryEventStore)store).GetAllEvents();
CollectionAssert.IsNotEmpty(allEvents);
Assert.AreSame(userRegistered, allEvents.First());
}
public async Task SubAggregate_should_write_to_root_aggregate()
{
var eventStore = new InMemoryEventStore();
var session = _sessionFactory(eventStore, _eventPublisherMock.Object);
var subAggregate = StubSubAggregate.Create("Walter White");
session.Add(subAggregate);
await session.CommitAsync();
var rootAggregate = await session.GetByIdAsync <StubAggregate>(subAggregate.AggregateId);
rootAggregate.Name.Should().Be(subAggregate.Name);
}
public void Event_retrieval_should_discriminate_between_timelines()
{
var eventDispatcherMockBuilder = new Mock <IEventDispatcher>();
var sut = new InMemoryEventStore(eventDispatcherMockBuilder.Object);
var sourceAccountId = Guid.NewGuid();
var destinationAccountId = Guid.NewGuid();
var withdrawalEvent = new WithdrawalEvent()
{
CurrentAccountId = sourceAccountId, Amount = 101
};
sut.Save(withdrawalEvent);
var depositEvent = new DepositEvent()
{
CurrentAccountId = sourceAccountId, Amount = 42
};
sut.Save(depositEvent);
var moneyTransferredEvent = new MoneyTransferredEvent()
{
SourceAccountId = sourceAccountId, DestinationAccountId = destinationAccountId, Amount = 42, TimelineId = Guid.NewGuid()
};
sut.Save(moneyTransferredEvent);
var eventDescriptors = new List <EventMapping>()
{
new EventMapping
{
AggregateIdPropertyName = nameof(WithdrawalEvent.CurrentAccountId),
EventType = typeof(WithdrawalEvent)
},
new EventMapping
{
AggregateIdPropertyName = nameof(MoneyTransferredEvent.SourceAccountId),
EventType = typeof(MoneyTransferredEvent)
}
};
var events = sut.RetrieveEvents(sourceAccountId, DateTime.Now, eventDescriptors, null);
Assert.Single(events);
}
public async Task WriteAndReadAsync()
{
var store = new InMemoryEventStore();
var v = await store.AppendToStreamAsync("test", 0, new IEvent[] { new TestEvent("t").AddTestMetaData <string>(new AggregateId("t")) });
var r = await store.LoadEventStreamAsync("test", 0);
var v2 = await store.AppendToStreamAsync("test", r.Item2, new IEvent[] { new TestEvent("t").AddTestMetaData <string>(new AggregateId("t"), (int)(r.Item2 + 1)) });
var r2 = await store.LoadEventStreamAsync("test", 0);
Assert.Equal(1, r.Item2);
Assert.Equal(v, r.Item2);
Assert.Equal(2, r2.Item2);
Assert.Equal(v2, r2.Item2);
}
public void GetById_returns_no_aggregate_with_a_different_ID_than_defined()
{
Given("a set of events with different aggregate ids in an event store",
testContext =>
{
var eventStore = new InMemoryEventStore();
eventStore.Insert(Uuid.NewId(), "Customer", new List <DomainEvent> {
new CustomerCreated(), new CustomerNameChanged()
});
eventStore.Insert(Uuid.NewId(), "Customer", new List <DomainEvent> {
new CustomerCreated()
});
eventStore.Insert(Uuid.NewId(), "Customer", new List <DomainEvent> {
new CustomerCreated()
});
testContext.State.EventStore = eventStore;
})
.And("an empty snapshot store",
testContext =>
{
testContext.State.SnapshotStore = new InMemorySnapshotStore();
})
.And("a configured domain context",
testContext =>
{
var eventBus = new Mock <IEventBus>().Object;
IEventStore eventStore = testContext.State.EventStore;
ISnapshotStore snapshotStore = testContext.State.SnapshotStore;
var domainRepository = new DomainRepository(eventStore, snapshotStore);
var domainContext = new DomainContext(eventBus, eventStore, snapshotStore, domainRepository);
testContext.State.DomainContext = domainContext;
})
.When("GetById for an aggregate with unknown id is called",
testContext =>
{
var aggregate =
((DomainContext)testContext.State.DomainContext).GetById <Customer>(Uuid.NewId());
testContext.State.Aggregate = aggregate;
})
.Then("it should return null",
testContext =>
{
object obj = testContext.State.Aggregate;
obj.Should().BeNull();
});
}
public void GivenAggregateWithUncommittedEvents_WhenSaved_ThenEventStoreShouldContainThoseEvents()
{
// Arrange
var eventStore = new InMemoryEventStore();
IRepository <User> repository = new EventSourcingRepository <User>(eventStore, new Mock <IConcurrencyMonitor>().Object);
var user = new User();
user.Register();
var expectedEvents = new object[] { new UserRegistered(user.Id) };
// Act
repository.Save(user);
// Assert
CollectionAssertAreJsonEqual(expectedEvents, eventStore.Events);
}
public void AggregateAndStatelessProcessEventsTest()
{
string firstAggregateId = "ar1";
string secondAggregateId = "ar2";
string firstCommandId = "c1";
string secondCommandId = "c2";
string thirdCommandId = "c3";
string fourthCommandId = "c4";
var item = new StockItem("item", "123");
string movementNumber = $"movement_{Guid.NewGuid()}";
var eventStore = new InMemoryEventStore();
var contextModel = new BoundedContextModel()
.WithAggregateRoot <Location>()
.WithEventHandler <MovedOut, Movement, MoveIn>(e => e.EventBody.Movement, c => c.Location);
var options = new DomainOptions(DomainOption.CacheRuntimeModel);
var engine = DomainFactory.CreateDomainExecutionEngine(contextModel, eventStore, options);
engine.Process(CommandFactory.Default.CreateCommand <CreateLocation>(firstCommandId, firstCommandId, firstAggregateId, new CreateLocation(firstAggregateId)));
engine.Process(CommandFactory.Default.CreateCommand <AdjustIn>(secondCommandId, secondCommandId, firstAggregateId, new AdjustIn($"adjustment_{Guid.NewGuid()}", firstAggregateId, item)));
engine.Process(CommandFactory.Default.CreateCommand <CreateLocation>(thirdCommandId, thirdCommandId, secondAggregateId, new CreateLocation(secondAggregateId)));
var results = engine.Process(CommandFactory.Default.CreateCommand <MoveOut>(fourthCommandId, fourthCommandId, firstAggregateId, new MoveOut(movementNumber, firstAggregateId, item, secondAggregateId))).ToList();
Assert.IsTrue(results.Count == 2);
Assert.IsInstanceOfType(results[0].EventBody, typeof(MovedOut));
Assert.IsTrue(results[0].AggregateId == firstAggregateId);
Assert.IsTrue(results[0].AggregateType == typeof(Location).FullName);
Assert.IsTrue(results[0].AggregateVersion == 3);
Assert.IsTrue(results[0].CommandId == fourthCommandId);
Assert.IsTrue(results[0].CorrelationId == fourthCommandId);
Assert.IsTrue(results[0].EventBodyType == typeof(MovedOut).FullName);
Assert.IsTrue(results[0].Id == $"{firstAggregateId}\\{results[0].AggregateVersion}");
Assert.IsInstanceOfType(results[1].EventBody, typeof(MovedIn));
Assert.IsTrue(results[1].AggregateId == secondAggregateId);
Assert.IsTrue(results[1].AggregateType == typeof(Location).FullName);
Assert.IsTrue(results[1].AggregateVersion == 2);
Assert.IsTrue(results[1].CommandId == $"{typeof(Movement).Name}\\{results[0].EventBody.Movement}\\{1}");
Assert.IsTrue(results[1].CorrelationId == fourthCommandId);
Assert.IsTrue(results[1].EventBodyType == typeof(MovedIn).FullName);
Assert.IsTrue(results[1].Id == $"{secondAggregateId}\\{results[1].AggregateVersion}");
}
public void WhenCreatingADependantViewDispatcherThenMaxValueIsNotZeroOrLess()
{
//arrange
var viewManager1 = new Mock <IViewManager>().Object;
var viewManager2 = new Mock <IViewManager>().Object;
var domainSerializer = new Mock <IDomainEventSerializer>().Object;
var eventStore = new InMemoryEventStore();
var aggregateRootRepo = new Mock <IAggregateRootRepository>().Object;
var domainTypemapper = new Mock <IDomainTypeNameMapper>().Object;
//act
var sut = new DependentViewManagerEventDispatcher(new[] { viewManager1 }, new[] { viewManager2 }, eventStore,
domainSerializer, aggregateRootRepo, domainTypemapper, null);
//assert
Assert.IsTrue(sut.MaxDomainEventsPerBatch >= 1);
}
private async Task <Session> ArrangeSessionAsync <TAggregate>(Guid aggregateId, IEventUpdateManager eventUpdateManager = null, params IDomainEvent[] arrangeEvents)
where TAggregate : Aggregate, new()
{
var metadataProviders = new IMetadataProvider[]
{
new AggregateTypeMetadataProvider(),
new EventTypeMetadataProvider(),
new CorrelationIdMetadataProvider()
};
var loggerFactory = new NoopLoggerFactory();
var eventPublisher = new EventPublisher(new StubEventRouter());
var eventStore = new InMemoryEventStore();
var eventSerializer = new EventSerializer(new JsonTextSerializer());
var snapshotSerializer = new SnapshotSerializer(new JsonTextSerializer());
var projectionSerializer = new ProjectionSerializer(new JsonTextSerializer());
var session = new Session(loggerFactory, eventStore, eventPublisher, eventSerializer, snapshotSerializer, projectionSerializer, eventUpdateManager: eventUpdateManager);
var aggregate = (TAggregate)Activator.CreateInstance(typeof(TAggregate), args: aggregateId);
aggregate.UpdateVersion(arrangeEvents.Length - 1);
var serializedEvents = arrangeEvents.Select((e, index) =>
{
index++;
var metadatas =
metadataProviders.SelectMany(md => md.Provide(aggregate, e, EventSource.Metadata.Empty)).Concat(new[]
{
new KeyValuePair <string, object>(MetadataKeys.EventId, Guid.NewGuid()),
new KeyValuePair <string, object>(MetadataKeys.EventVersion, (aggregate.Version + index))
});
return(eventSerializer.Serialize(aggregate, e, new EventSource.Metadata(metadatas)));
});
eventStore.BeginTransaction();
await eventStore.SaveAsync(serializedEvents);
await eventStore.CommitAsync();
return(session);
}
public void ReadAndWriteEvent()
{
var ut = new InMemoryEventStore();
var streamName = "streamName";
ut.Append(new CreateStreamEvent(streamName, StreamPositions.Any, new TestEvent("name")));
var events = ut.ReadStream(streamName);
Assert.Single(events);
var e = events.First();
Assert.IsType <TestEvent>(e.Event);
var actualEvent = (TestEvent)e.Event;
Assert.Equal("name", actualEvent.Name);
}
public void WriteEventReadFromCategory()
{
var ut = new InMemoryEventStore();
var streamName = "streamName";
ut.Append(new CreateStreamEvent(streamName, StreamPositions.Any, new TestEvent("name")));
var events = ut.ReadStream("ca-streamName");
Assert.Single(events);
var e = events.First().GetOriginatingEvent;
Assert.IsType <TestEvent>(e);
var actualEvent = (TestEvent)e;
Assert.Equal("name", actualEvent.Name);
}
public void ExeptionIsWrappedInEventTest()
{
string commandId = "c1";
string experimentId = Guid.NewGuid().ToString();
var eventStore = new InMemoryEventStore();
var contextModel = new BoundedContextModel().WithAssemblyContaining <Experiment>().WithExceptionEvent <BadEvent>((e) => new BadEvent(e));
var options = new DomainOptions(DomainOption.CacheRuntimeModel);
var engine = DomainFactory.CreateDomainExecutionEngine(contextModel, eventStore, options);
var result = engine.Process(CommandFactory.Default.CreateCommand <PerformBadExperiment>(commandId, commandId, experimentId, new PerformBadExperiment(true)));
Assert.IsNotNull(result.FirstOrDefault(e => e.EventBody is BadEvent));
}
public void MultipleOptionalEventsAllNullTest()
{
string commandId = "c1";
string experimentId = Guid.NewGuid().ToString();
var eventStore = new InMemoryEventStore();
var contextModel = new BoundedContextModel().WithAssemblyContaining <Experiment>();
var options = new DomainOptions(DomainOption.CacheRuntimeModel);
var engine = DomainFactory.CreateDomainExecutionEngine(contextModel, eventStore, options);
var results = engine.Process(CommandFactory.Default.CreateCommand <PerformExperiment>(commandId, commandId, experimentId, new PerformExperiment(false, false)));
Assert.IsTrue(results.Count() == 0);
}
public void GivenEmptyEventStore_WhenAddingEventsInBulk_ThenStoreShouldContainThoseEvents()
{
// Arrange
IEventStore store = new InMemoryEventStore(new ConsoleLogger());
var user = new User();
user.Register();
user.ChangePassword("newpassword");
// Act
store.Save <User>(user.Id.ToString(), 0, user.GetUncommittedEvents());
// Assert
var allEvents = ((InMemoryEventStore)store).GetAllEvents();
CollectionAssert.IsNotEmpty(allEvents);
CollectionAssert.AreEqual(user.GetUncommittedEvents(), allEvents);
}
public async Task Verify_custom_metadata()
{
// Arrange
var eventStore = new InMemoryEventStore();
var eventsMetadataService = new EventsMetadataService();
var server = TestServerFactory(eventStore, eventsMetadataService);
var response = await server.CreateRequest("/command/foo").PostAsync();
var eventsWithMetadata = eventsMetadataService.GetEvents().ToList();
eventsWithMetadata.Count().Should().Be(1);
var fakeUser = eventsWithMetadata[0].Metadata.GetValue(FakeUserMetadataProvider.MetadataKey, e => (User)e);
fakeUser.Name.Should().Be("Xomano");
fakeUser.UserCode.Should().Be(123);
}
public void Setup()
{
var eventstore = new InMemoryEventStore(() => DateTime.UtcNow);
var geraete = new Geraetemodul();
_clientapi = new KasseClientApi(
new ModulApi.Produkte.Produktmodul(),
geraete,
new VerkaufCommandHandler(eventstore,
ex => { throw new Exception("Fehler in Testausführung: " + ex.Message, ex); })
);
_queryapi = new KasseQueryApi(new VerkaufQuery(eventstore), geraete);
_aktuellerBon = null;
_queryapi.AktuellerBon.Subscribe(bon => _aktuellerBon = bon);
}
public void WhenCreatingADependantViewDispatcherThenMaxValueIsNotZeroOrLess()
{
//arrange
var viewManager1 = new Mock<IViewManager>().Object;
var viewManager2 = new Mock<IViewManager>().Object;
var domainSerializer = new Mock<IDomainEventSerializer>().Object;
var eventStore = new InMemoryEventStore();
var aggregateRootRepo = new Mock<IAggregateRootRepository>().Object;
var domainTypemapper = new Mock<IDomainTypeNameMapper>().Object;
//act
var sut = new DependentViewManagerEventDispatcher(new[] { viewManager1 }, new[] { viewManager2 }, eventStore,
domainSerializer, aggregateRootRepo, domainTypemapper, null);
//assert
Assert.IsTrue(sut.MaxDomainEventsPerBatch >= 1);
}
public async Task Should_do_something()
{
var eventStore = new InMemoryEventStore();
var server = TestServerFactory(eventStore);
var response = await server.CreateRequest("/command/foo").PostAsync();
var result = await response.Content.ReadAsStringAsync();
var aggregateId = ExtractAggregateIdFromResponseContent(result);
response = await server.CreateRequest($"/command/foo/{aggregateId}/doSomething").PostAsync();
response.StatusCode.Should().Be(HttpStatusCode.OK);
aggregateId.Should().NotBeEmpty();
}
void FillInDefaults()
{
_services.AddScoped(context =>
{
var eventStore = context.GetService <InMemoryEventStore>();
var aggregateRootRepository = context.GetService <IAggregateRootRepository>();
var eventDispatcher = context.GetService <IEventDispatcher>();
var serializer = context.GetService <IDomainEventSerializer>();
var commandMapper = context.GetService <ICommandMapper>();
var domainTypeMapper = context.GetService <IDomainTypeNameMapper>();
var testContext = new TestContext(eventStore, aggregateRootRepository, eventDispatcher, serializer, commandMapper, domainTypeMapper);
context
.GetServices <Action <TestContext> >().ToList()
.ForEach(action => action(testContext));
testContext.Initialize();
return(testContext);
});
var memoryEventStore = new InMemoryEventStore();
_services.AddScoped(x => memoryEventStore);
_services.AddScoped <IEventStore>(x => memoryEventStore);
_services.AddScoped <IEventDispatcher>(x =>
new ViewManagerEventDispatcher(
x.GetService <IAggregateRootRepository>(),
x.GetService <InMemoryEventStore>(),
x.GetService <IDomainEventSerializer>(),
x.GetService <IDomainTypeNameMapper>()));
_services.AddScoped <IAggregateRootRepository>(context =>
new DefaultAggregateRootRepository(
context.GetService <InMemoryEventStore>(),
context.GetService <IDomainEventSerializer>(),
context.GetService <IDomainTypeNameMapper>()));
_services.AddScoped <IDomainEventSerializer>(context => new JsonDomainEventSerializer("<events>"));
_services.AddScoped <ICommandMapper>(context => new DefaultCommandMapper());
_services.AddScoped <IDomainTypeNameMapper>(context => new DefaultDomainTypeNameMapper());
}
public void GivenAggregateWithUncommittedEvents_WhenSaved_ThenEventStoreShouldContainThoseEvents()
{
// Arrange
var eventStore = new InMemoryEventStore(new ConsoleLogger());
IRepository <User> repository = new EventSourcingRepository <User>(eventStore, new Mock <IConcurrencyMonitor>().Object, _logger);
var user = new User();
user.Register();
var expectedEvents = new object[] { new UserRegistered(user.Id) };
// Act
repository.Save(user);
// Assert
var comparisonResult = _comparer.AreEqual(expectedEvents, eventStore.GetAllEvents());
Assert.That(comparisonResult.AreEqual, comparisonResult.InequalityReason);
}
public FullAggregatorTests()
{
var container = ContainerBuilder.Build(new Configuration());
_eventStore = container.GetInstance <InMemoryEventStore>();
_keywordDictionary.IsValidKeyword(Arg.Any <string>()).Returns(true);
_webPageDownloader.Download(Arg.Any <string>()).Returns("<html></html>");
container.Inject(_feedReader);
container.Inject(_eventPositionRepository);
container.Inject(_keywordDictionary);
container.Inject(_webPageDownloader);
container.Inject((IEventStoreExtended)_eventStore);
container.Inject((IEventStore)_eventStore);
container.Inject((IEventBus)_inMemoryBus);
container.Inject((ILogger) new EmptyLogger());
_aggregator = container.GetInstance <Aggregator>();
}
public void Test()
{
var newMessages = new List <object>();
var bus = new MessageBus();
bus.RegisterHandler <object>(newMessages.Add);
var eventStore = new InMemoryEventStore(bus, GivenTheseEvents());
var repository = new DomainRepository(eventStore);
RegisterHandler(bus, repository);
try
{
bus.Handle(WhenThisHappens());
}
catch (Exception e)
{
var expectedException = ThisExceptionShouldOccur();
if (expectedException == null)
{
Assert.Fail(e.Message);
}
if (expectedException.GetType().IsAssignableFrom(e.GetType()))
{
Assert.AreEqual(expectedException.Message, e.Message);
return;
}
Assert.Fail("Expected exception of type {0} with message {1} but got exception of type {2} with message {3}", expectedException.GetType(), expectedException.Message, e.GetType(), e.Message);
}
var expectedEvents = TheseEventsShouldOccur().ToList();
var comparer = new CompareObjects();
if (!comparer.Compare(expectedEvents, newMessages))
{
Assert.Fail(comparer.DifferencesString);
}
}
public static IUnityContainer ResolvePersistence(IUnityContainer container, PersistencePlugin selectedPlugin, string microserviceName,
string connectionString,
bool persistIncomingPayloads,
bool persistSnapshots,
// Sql Based persistence
Func <InMemoryEventStore <TStream>, InMemoryEventStore <TStream> > setupInMemoryPersistence,
Func <string, ITextSerializer, string, bool> consumerFilter)
{
switch (selectedPlugin)
{
case PersistencePlugin.InMemory:
var persistence = new InMemoryEventStore <TStream>(
microserviceName,
container.Resolve <IUtcTimeProvider>(),
container.Resolve <ITextSerializer>(),
container.Resolve <IGuidProvider>(),
container.Resolve <ILogger>(),
persistIncomingPayloads,
consumerFilter);
if (setupInMemoryPersistence != null)
{
setupInMemoryPersistence.Invoke(persistence);
}
container.RegisterInstance <ISubscriptionRepository>(persistence);
container.RegisterInstance <IEventStore <TStream> >(persistence);
break;
case PersistencePlugin.SqlServer:
ResolveForSqlServer(container, microserviceName, connectionString, persistIncomingPayloads, persistSnapshots, consumerFilter);
break;
case PersistencePlugin.SqlServerCe:
ResolveForSqlServerCe(container, microserviceName, connectionString, persistIncomingPayloads, consumerFilter);
break;
default:
throw new InvalidOperationException("The selected plug in is not available");
}
return(container);
}
public void GivenEventStorePopulatedWithManyEventsForAnAggregate_WhenLoadingForSpecificVersion_ThenShouldOnlyLoadEventsUpToAndIncludingThatVersion()
{
// Arrange
IEventStore store = new InMemoryEventStore(new ConsoleLogger());
var id = Guid.NewGuid();
var allEvents = new EventChain().Add(new UserRegistered(id))
.Add(new UserChangedPassword("pwd1"))
.Add(new UserChangedPassword("pwd2"))
.Add(new UserChangedPassword("pwd3"))
.Add(new UserChangedPassword("pwd4"));
store.Save <User>(id.ToString(), 0, allEvents);
// Act
IEnumerable <IEvent> version3 = store.Load <User>(id.ToString(), allEvents[2].Version).Events;
// Assert
CollectionAssert.AreEqual(allEvents.Take(3).ToArray(), version3);
}
public async Task Should_publish_in_correct_order()
{
var events = new List <IDomainEvent>();
var eventStore = new InMemoryEventStore();
_eventPublisherMock.Setup(e => e.PublishAsync(It.IsAny <IEnumerable <IDomainEvent> >())).Callback <IEnumerable <IDomainEvent> >(evts => events.AddRange(evts)).Returns(Task.CompletedTask);
_eventPublisherMock.Setup(e => e.CommitAsync()).Returns(Task.CompletedTask);
var session = _sessionFactory(eventStore, _eventPublisherMock.Object, null, null);
var stubAggregate1 = StubAggregate.Create("Walter White");
var stubAggregate2 = StubAggregate.Create("Heinsenberg");
stubAggregate1.ChangeName("Saul Goodman");
stubAggregate2.Relationship(stubAggregate1.Id);
stubAggregate1.ChangeName("Jesse Pinkman");
await session.AddAsync(stubAggregate1).ConfigureAwait(false);
await session.AddAsync(stubAggregate2).ConfigureAwait(false);
await session.SaveChangesAsync().ConfigureAwait(false);
events[0].Should().BeOfType <StubAggregateCreatedEvent>().Which.AggregateId.Should().Be(stubAggregate1.Id);
events[0].Should().BeOfType <StubAggregateCreatedEvent>().Which.Name.Should().Be("Walter White");
events[1].Should().BeOfType <StubAggregateCreatedEvent>().Which.AggregateId.Should().Be(stubAggregate2.Id);
events[1].Should().BeOfType <StubAggregateCreatedEvent>().Which.Name.Should().Be("Heinsenberg");
events[2].Should().BeOfType <NameChangedEvent>().Which.AggregateId.Should().Be(stubAggregate1.Id);
events[2].Should().BeOfType <NameChangedEvent>().Which.Name.Should().Be("Saul Goodman");
events[3].Should().BeOfType <StubAggregateRelatedEvent>().Which.AggregateId.Should().Be(stubAggregate2.Id);
events[3].Should().BeOfType <StubAggregateRelatedEvent>().Which.StubAggregateId.Should().Be(stubAggregate1.Id);
events[4].Should().BeOfType <NameChangedEvent>().Which.AggregateId.Should().Be(stubAggregate1.Id);
events[4].Should().BeOfType <NameChangedEvent>().Which.Name.Should().Be("Jesse Pinkman");
}
static void Main()
{
var eventQueue = new InMemoryEventQueue();
var eventStore = new InMemoryEventStore();
var eventHandler = new EventHandler(eventQueue, eventStore);
// Write side
var service = new ItemService(eventHandler);
var itemId = Guid.NewGuid();
var properties = new Dictionary<string, object>
{
{"name", "somename"},
{"creator", "adg"},
{"creationTime", DateTime.Now.ToUniversalTime()}
};
var dimension = new Dictionary<string, string>
{
{"language", "en"}
};
var fields = new Dictionary<Guid, string>()
{
{Guid.NewGuid(), "Hello title!"},
{Guid.NewGuid(), "Hello world!"}
};
service.Execute(new CreateItemCommand(itemId, properties));
// Wait 500ms
// Read item from tempStore
service.Execute(new AddVersionCommand(itemId, dimension));
// Wait 500ms
// Read item from tempStore
service.Execute(new FieldsUpdatedCommand(itemId, fields));
// Wait 500ms
// Read item from tempStore
}
public static PretendApplication Bootstrap(ILogger logger)
{
var eventBus = EventBus.GetInstance();
var eventStore = InMemoryEventStore.GetInstance();
IRepository AggregateRepositoryProvider() =>
new AggregateRepository(eventStore, eventBus);
var shoppingCartStore = InMemoryReadModelStore <ShoppingCartReadModel> .GetInstance();
IShoppingCartReadModelRepository ShoppingCartReadModelRepositoryProvider() =>
new ShoppingCartReadModelRepository(shoppingCartStore);
var orderStore = InMemoryReadModelStore <OrderReadModel> .GetInstance();
IOrderReadModelRepository OrderReadModelRepositoryProvider() =>
new OrderReadModelRepository(orderStore);
var commandHandlerFactory = CommandHandlerFactoryRegistration.NewCommandHandlerFactory(AggregateRepositoryProvider);
var commandDispatcher = new CommandDispatcher(commandHandlerFactory);
IRepository SagaRepositoryProvider() =>
new SagaRepository(AggregateRepositoryProvider(), commandDispatcher);
IContextEventProducer ContextEventProducer() =>
EventProducerFactory.GetEventProducer(logger);
var eventHandlerFactory = EventHandlerFactoryRegistration.NewEventHandlerFactory(
AggregateRepositoryProvider,
SagaRepositoryProvider,
ShoppingCartReadModelRepositoryProvider,
OrderReadModelRepositoryProvider,
ContextEventProducer);
var eventDispatcher = new EventDispatcher(eventHandlerFactory);
var eventProcessor = new EventProcessor(eventBus, eventDispatcher);
return(new PretendApplication(
ShoppingCartReadModelRepositoryProvider(),
OrderReadModelRepositoryProvider(),
commandDispatcher));
}
public void ProcessCommandUsingCustomHandlerTest()
{
var commandId = "command1";
var correlationId = "command1";
var aggregateId = "location1";
var contextModel = new BoundedContextModel()
.WithAssemblyContaining <Location>()
.WithCommandHandler <MoveIn, Location, MovedIn>();
var eventStore = new InMemoryEventStore();
var item = new StockItem("item", "123");
var command = CommandFactory.Default.CreateCommand <MoveIn>(commandId, correlationId, aggregateId, new MoveIn($"movement_{Guid.NewGuid()}", "locationA", item, "locationB"));
var engine = DomainFactory.CreateDomainExecutionEngine(contextModel, eventStore, DomainOptions.Defaults);
engine.Process(command);
}
public async Task Should_retrieve_the_aggregate_from_tracking()
{
var eventStore = new InMemoryEventStore();
var session = _sessionFactory(eventStore, _eventPublisherMock.Object, null);
var stubAggregate1 = StubAggregate.Create("Walter White");
await session.AddAsync(stubAggregate1).ConfigureAwait(false);
await session.SaveChangesAsync().ConfigureAwait(false);
stubAggregate1.ChangeName("Changes");
var stubAggregate2 = await session.GetByIdAsync <StubAggregate>(stubAggregate1.Id).ConfigureAwait(false);
stubAggregate2.ChangeName("More changes");
stubAggregate1.Should().BeSameAs(stubAggregate2);
}
public void TryReplicating()
{
var serializer = new JsonDomainEventSerializer();
var source = new InMemoryEventStore();
var destination = new InMemoryEventStore();
var seqNo = 0;
Func<string, EventData> getRecognizableEvent = text => serializer.Serialize(new RecognizableEvent(text)
{
Meta =
{
{DomainEvent.MetadataKeys.AggregateRootId, "268DD0C0-529F-4242-9D53-601A88BB1813"},
{DomainEvent.MetadataKeys.SequenceNumber, (seqNo).ToString(Metadata.NumberCulture)},
{DomainEvent.MetadataKeys.GlobalSequenceNumber, (seqNo++).ToString(Metadata.NumberCulture)},
}
});
// arrange
using (var eventReplicator = new EventReplicator(source, destination))
{
eventReplicator.Start();
Thread.Sleep(TimeSpan.FromSeconds(2));
// act
source.Save(Guid.NewGuid(), new[] { getRecognizableEvent("hello") });
source.Save(Guid.NewGuid(), new[] { getRecognizableEvent("there") });
source.Save(Guid.NewGuid(), new[] { getRecognizableEvent("my") });
source.Save(Guid.NewGuid(), new[] { getRecognizableEvent("friend") });
Thread.Sleep(TimeSpan.FromSeconds(1));
}
// assert
var greeting = string.Join(" ", destination
.Select(x => serializer.Deserialize(x))
.OfType<RecognizableEvent>()
.Select(e => e.Id));
Assert.That(greeting, Is.EqualTo("hello there my friend"));
}
public InMemoryEventStoreFactory()
{
_eventStore = new InMemoryEventStore();
}
public InMemoryEventStoreFactory()
{
_eventStore = new InMemoryEventStore(new JsonDomainEventSerializer());
}
