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