public void TrySaveMultipleEvents() { // arrange var eventStore = new MemoryEventStore(); var streamId = Guid.NewGuid(); var events = new[] { new Event { Id = 1, Value = "One" }, new Event { Id = 2, Value = "Two" }, }; string commitState; string actualCommitState; // act eventStore.CommitStream(streamId, events, Guid.NewGuid(), null, out commitState); var actualEvents = eventStore.GetStream(streamId, 0, out actualCommitState); // assert actualEvents.Count().Should().Be(2); actualEvents.First().Should().BeOfType <Event>(); actualEvents.Last().Should().BeOfType <Event>(); actualEvents.Cast <Event>().First().ShouldBeEquivalentTo(events[0]); actualEvents.Cast <Event>().Last().ShouldBeEquivalentTo(events[1]); actualCommitState.Should().Be(commitState); }
public void Initialize() { _memoryEventStore = new MemoryEventStore(); _quizUseCases = new QuizUseCases(_memoryEventStore); _processManager = new QuizCreationCancellationPolicy(_quizUseCases); _memoryEventStore.SubscribeToAll(_processManager.HandleEvent); }
public void TrySaveEventsForMultipleStreams() { // arrange var eventStore = new MemoryEventStore(); var stream1Id = Guid.NewGuid(); var stream2Id = Guid.NewGuid(); var events1 = new[] { new Event { Id = 1, Value = "One" } }; var events2 = new[] { new Event { Id = 2, Value = "Two" } }; string stream1CommitState; string stream2CommitState; string actualStream1CommitState; string actualStream2CommitState; // act eventStore.CommitStream(stream1Id, events1, Guid.NewGuid(), null, out stream1CommitState); eventStore.CommitStream(stream2Id, events2, Guid.NewGuid(), null, out stream2CommitState); var stream1Events = eventStore.GetStream(stream1Id, 0, out actualStream1CommitState); var stream2Events = eventStore.GetStream(stream2Id, 0, out actualStream2CommitState); // assert stream1Events.Count().Should().Be(1); stream1Events.Single().Should().BeOfType <Event>(); stream1Events.Cast <Event>().Single().ShouldBeEquivalentTo(events1[0]); actualStream1CommitState.Should().Be(stream1CommitState); stream2Events.Count().Should().Be(1); stream2Events.Single().Should().BeOfType <Event>(); stream2Events.Cast <Event>().Single().ShouldBeEquivalentTo(events2[0]); actualStream2CommitState.Should().Be(stream2CommitState); }
public async Task ShouldMapOlderEventFormatsToNewEventTypesAsync() { var eventWithVersion1 = new VersionedEvent1 { Property1 = "property1" }; var eventWithVersion2 = new VersionedEvent2 { Property1 = "property1", Property2 = "property2" }; var eventWithVersion3 = new VersionedEvent { Property3 = "test" }; var eventStore = new MemoryEventStore(); var savedEvent1 = await eventStore.Save(eventWithVersion1); var savedEvent2 = await eventStore.Save(eventWithVersion2); var savedEvent3 = await eventStore.Save(eventWithVersion3); var ids = new List <Guid> { savedEvent1.Id, savedEvent2.Id, savedEvent3.Id }; var events = await eventStore.Get(ids); var eventTypeCount = events .Select(e => e.GetType()) .Where(e => e.Name == "VersionedEvent") .Count(); Assert.AreEqual(3, eventTypeCount); }
public void TestInitialization() { eventStore = new MemoryEventStore(); reconciliationService = new ReconciliationService(); dispatcher = new Dispatcher(eventStore, reconciliationService); }
public void TrySaveEventsInMultipleCommits() { // arrange var eventStore = new MemoryEventStore(); var streamId = Guid.NewGuid(); var events1 = new[] { new Event { Id = 1, Value = "One" } }; var events2 = new[] { new Event { Id = 2, Value = "Two" } }; string firstCommitState; string secondCommitState; string actualCommitState; // act eventStore.CommitStream(streamId, events1, Guid.NewGuid(), null, out firstCommitState); eventStore.CommitStream(streamId, events2, Guid.NewGuid(), firstCommitState, out secondCommitState); var actualEvents = eventStore.GetStream(streamId, 0, out actualCommitState); // assert actualEvents.Count().Should().Be(2); actualEvents.First().Should().BeOfType <Event>(); actualEvents.Last().Should().BeOfType <Event>(); actualEvents.Cast <Event>().First().ShouldBeEquivalentTo(events1[0]); actualEvents.Cast <Event>().Last().ShouldBeEquivalentTo(events2[0]); actualCommitState.Should().Be(secondCommitState); }
public void SaveEvents_NullObject_ShouldThrowException() { // Arrange IComparer <Event> comparer = CreateEventComparer(); IEventStore <uint, Event> eventStore = new MemoryEventStore <uint, Event>(comparer); // Act, Assert Assert.Throws <ArgumentNullException>(() => eventStore.SaveEvents(1, null)); }
private MemoryEventDispatcher( IEventDispatcher eventDispatcher, MemoryEventStore eventStore, MemoryNotificationService notificationService) : base(eventDispatcher, eventStore, notificationService, Guid.Empty, 50) { this.eventStore = eventStore; this.notificationService = notificationService; }
public Startup() { MemoryEventStore = new MemoryEventStore(); QuizUseCases = new QuizUseCases(MemoryEventStore); ProcesManager = new QuizCreationCancellationPolicy(QuizUseCases); var r = new RegisteredPlayers(); MemoryEventStore.SubscribeToAll(ProcesManager.HandleEvent); MemoryEventStore.SubscribeToAll(r.HandleEvent); }
public async Task ShouldReturnNewEventInstanceAsync() { var eventStore = new MemoryEventStore(); var eventToBeSaved = new TestEvent { Property1 = "test" }; var storedEvent = await eventStore.Save(eventToBeSaved); Assert.AreNotSame(eventToBeSaved, storedEvent); }
public async Task ShouldPopulateTheIdFieldAsync() { var eventStore = new MemoryEventStore(); var eventToBeSaved = new TestEvent { Property1 = "test" }; var storedEvent = await eventStore.Save(eventToBeSaved); Assert.AreNotEqual(Guid.Empty, storedEvent.Id); }
public void ShouldInxedEventAsync() { var savedEvent = new TestEvent { Property1 = "test", Id = new Guid() }; var eventStore = new MemoryEventStore(); Action action = async() => await eventStore.Index(savedEvent, "testIndex", new { Property1 = "" }); action.ShouldNotThrow(); }
public async Task ShouldSaveEventsAsync() { var eventStore = new MemoryEventStore(); var eventToBeSaved = new TestEvent { Property1 = "test" }; var storedEvent = await eventStore.Save(eventToBeSaved); Assert.IsNotNull(storedEvent); }
public void GetEventsById_OnEmptyStore_ShouldReturnEmptyCollection() { // Arrange IComparer <Event> comparer = CreateEventComparer(); IEventStore <uint, Event> eventStore = new MemoryEventStore <uint, Event>(comparer); // Act IReadOnlyCollection <Event> result = eventStore.GetEventsById(1); // Assert Assert.Empty(result); }
public async Task ShouldNotAffectOriginalInstanceDuringSaveAsync() { var eventStore = new MemoryEventStore(); var eventToBeSaved = new TestEvent { Property1 = "test" }; var originalEventSerialized = JsonConvert.SerializeObject(eventToBeSaved); var storedEvent = await eventStore.Save(eventToBeSaved); Assert.AreEqual(originalEventSerialized, JsonConvert.SerializeObject(eventToBeSaved)); }
public async Task ShouldGetByIdAsync() { var eventStore = new MemoryEventStore(); var eventToBeSaved = new TestEvent { Property1 = "test" }; var storedEvent = await eventStore.Save(eventToBeSaved); var retreivedEvent = await eventStore.Get <TestEvent>(storedEvent.Id); Assert.AreEqual(JsonConvert.SerializeObject(storedEvent), JsonConvert.SerializeObject(retreivedEvent)); }
public void SaveEvents_WithNotEmptyArray_ShouldReturnTrue() { // Arrange Event[] fakeEvents = { new FakeEvent() }; IComparer <Event> comparer = CreateEventComparer(); IEventStore <uint, Event> eventStore = new MemoryEventStore <uint, Event>(comparer); // Act bool result = eventStore.SaveEvents(1, fakeEvents); // Assert Assert.True(result); }
protected override void ConfigureWebHost(IWebHostBuilder builder) { var eventStore = new MemoryEventStore(); AddUsers(eventStore); AddStocks(eventStore); AddPortfolios(eventStore); builder.ConfigureTestServices(x => { x.AddSingleton <IEventStore>(eventStore); x.RemoveAll <IHostedService>(); x.AddScoped <IPortfolioAccessor>(_ => _PortfolioAccessor); }); }
public void GetEventsById_WithExistingId_ShouldReturnEventCollection() { // Arrange uint eventAggregateId = 1; Event[] fakeEvents = { new FakeEvent() }; IComparer <Event> comparer = CreateEventComparer(); IEventStore <uint, Event> eventStore = new MemoryEventStore <uint, Event>(comparer); // Act eventStore.SaveEvents(eventAggregateId, fakeEvents); IEnumerable <Event> result = eventStore.GetEventsById(eventAggregateId); // Assert Assert.NotNull(result); Assert.Single(result); }
public void GetEventsById_WithUnexistingId_ShouldReturnEmptyCollection() { // Arrange uint eventAggregateId = 1; Event[] fakeEvents = { new FakeEvent() }; IComparer <Event> comparer = CreateEventComparer(); IEventStore <uint, Event> eventStore = new MemoryEventStore <uint, Event>(comparer); eventStore.SaveEvents(eventAggregateId, fakeEvents); // Act IReadOnlyCollection <Event> result = eventStore.GetEventsById(2); // Assert Assert.Empty(result); }
private static void Main() { IComparer <Event <uint> > comparer = CreateEventComparer(); IEventStore <uint, Event <uint> > eventStore = new MemoryEventStore <uint, Event <uint> >(comparer); for (uint i = 0; i < 10; i++) { List <Event <uint> > events = new List <Event <uint> >(); events.Add(new OrderCreatedEvent(i)); events.Add(new OrderDateChangedEvent(i, DateTime.Now.AddDays(i))); events.Add(new OrderDeletedEvent(i)); eventStore.SaveEvents(i, events); } IReadOnlyCollection <Event <uint> > found = eventStore.GetEventsById(1); Console.WriteLine($"Found events: {found.Count}"); Console.ReadKey(); }
private static void Main() { // units of work IComparer <Event <uint> > comparer = CreateEventComparer(); IEventStore <uint, Event <uint> > eventStore = new MemoryEventStore <uint, Event <uint> >(comparer); IUnitOfWork aggregatesUnitOfWork = new AggregateUnitOfWorkFactory().Create(eventStore); IUnitOfWork domainUnitOfWork = new DomainUnitOfWorkFactory().Create(); // messaging IMessageBus <object> eventBus = new MemoryMessageBus <object>(); OrderCommandsHandler orderCommandsHandler = new OrderCommandsHandler(aggregatesUnitOfWork); eventBus.Subscribe <CreateOrderCommand>(orderCommandsHandler); eventBus.Subscribe <ChangeOrderDateCommand>(orderCommandsHandler); eventBus.Subscribe <DeleteOrderCommand>(orderCommandsHandler); OrderEventsHandler orderEventsHandler = new OrderEventsHandler(domainUnitOfWork, eventBus); eventBus.Subscribe <OrderCreatedEvent>(orderEventsHandler); eventBus.Subscribe <OrderDateChangedEvent>(orderEventsHandler); eventBus.Subscribe <OrderDeletedEvent>(orderEventsHandler); // commands simulation uint iterations = 3; for (uint i = 0; i < iterations; i++) { eventBus.Publish(new CreateOrderCommand(i)); eventBus.Publish(new ChangeOrderDateCommand(i, DateTime.Now.AddDays(1))); eventBus.Publish(new DeleteOrderCommand(i)); } for (uint i = 0; i < iterations; i++) { OrderDto found = domainUnitOfWork.GetRepository <OrderDto>().GetById(i); Console.WriteLine($"{nameof(OrderDto.Id)}: {found.Id}"); Console.WriteLine($"{nameof(OrderDto.Date)}: {found.Date}"); } Console.ReadKey(); }
public void ExpectClientSideConcurrencyException() { // arrange var eventStore = new MemoryEventStore(); var streamId = Guid.NewGuid(); var events1 = new[] { new Event { Id = 1, Value = "One" } }; var events2 = new[] { new Event { Id = 1, Value = "AnotherOne" } }; string commitState; eventStore.CommitStream(streamId, events1, Guid.NewGuid(), null, out commitState); // act Action action = () => eventStore.CommitStream(streamId, events2, Guid.NewGuid(), null, out commitState); // assert action.ShouldThrow <ConcurrencyException>(); }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); RegisterRoutes(RouteTable.Routes); var kernel = new StandardKernel( new KernelRegistrationModule(), new BusModule(), new EventStoreModule(), new RepositoryModule()); var bus = new FakeBus(); var storage = new MemoryEventStore(bus); var rep = new Repository <InventoryItem>(storage); var commands = new InventoryCommandHandlers(rep); bus.RegisterHandler <CheckInItemsToInventory>(commands.Handle); bus.RegisterHandler <CreateInventoryItem>(commands.Handle); bus.RegisterHandler <DeactivateInventoryItem>(commands.Handle); bus.RegisterHandler <RemoveItemsFromInventory>(commands.Handle); bus.RegisterHandler <RenameInventoryItem>(commands.Handle); var detail = new InvenotryItemDetailView(); bus.RegisterHandler <InventoryItemCreated>(detail.Handle); bus.RegisterHandler <InventoryItemDeactivated>(detail.Handle); bus.RegisterHandler <InventoryItemRenamed>(detail.Handle); bus.RegisterHandler <ItemsCheckedInToInventory>(detail.Handle); bus.RegisterHandler <ItemsRemovedFromInventory>(detail.Handle); var list = new InventoryListView(); bus.RegisterHandler <InventoryItemCreated>(list.Handle); bus.RegisterHandler <InventoryItemRenamed>(list.Handle); bus.RegisterHandler <InventoryItemDeactivated>(list.Handle); ServiceLocator.Bus = bus; }
public void ExpectServerSideConcurrencyException() { // arrange var eventStore = new MemoryEventStore(); var streamId = Guid.NewGuid(); var events = new[] { new Event { Id = 1, Value = "One" } }; string commitState; var mutex = (Mutex)typeof(MemoryEventStore).GetField("mutex", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(eventStore); // NOTE (Cameron): This will cause the memory event store to attempt to acquire the same lock as the commit attempt below. using (new ExclusiveCodeBlock(mutex)) { // act Action action = () => eventStore.CommitStream(streamId, events, Guid.NewGuid(), null, out commitState); // assert action.ShouldThrow <ConcurrencyException>(); } }
public async Task ShouldGetByIdsAsync() { var eventStore = new MemoryEventStore(); var eventToBeSaved1 = new TestEvent { Property1 = "test" }; var eventToBeSaved2 = new TestEvent2 { Property1 = "property1", Property2 = "property2" }; var storedEvent1 = await eventStore.Save(eventToBeSaved1); var storedEvent2 = await eventStore.Save(eventToBeSaved2); var expectedEvents = new List <Event> { storedEvent1, storedEvent2 }; var retreivedEvents = await eventStore.Get(new List <Guid> { storedEvent1.Id, storedEvent2.Id }); Assert.AreEqual(JsonConvert.SerializeObject(expectedEvents), JsonConvert.SerializeObject(retreivedEvents)); }
public async Task ShouldRetrieveEventFromIndexAsync() { var unsavedEvent1 = new TestEvent { Property1 = "test" }; var unsavedEvent2 = new TestEvent2 { Property1 = "test", Property2 = "test2" }; var eventStore = new MemoryEventStore(); var savedEvent1 = await eventStore.Save(unsavedEvent1); var savedEvent2 = await eventStore.Save(unsavedEvent2); object indexKey = new { Property1 = "" }; var indexName = "indexName"; await eventStore.Index(savedEvent1, indexName, indexKey); await eventStore.Index(savedEvent2, indexName, indexKey); var indexedEvents = await eventStore.GetFromIndex(indexName, new { Property1 = "test" }); Assert.AreEqual(2, indexedEvents.Count()); }
public void Initialize() { _memoryEventStore = new MemoryEventStore(); Subject = new QuizCreationCancellationPolicy(new QuizUseCases(_memoryEventStore)); _memoryEventStore.SubscribeToAll(Subject.HandleEvent); }
public void Initialize() { Subject = new RegisteredPlayers(); _memoryEventStore = new MemoryEventStore(); _memoryEventStore.SubscribeToAll(Subject.HandleEvent); }
public void WhenEventPersisted_ThenCanObserveIt() { var store = new MemoryEventStore<int>(); var product = new Product(5, "DevStore"); product.Publish(1); product.Publish(2); product.Publish(3); product.GetChanges().ToList() .ForEach(e => store.Save(product, e)); product = new Product(6, "WoVS"); product.Publish(1); product.Publish(2); product.GetChanges().ToList() .ForEach(e => store.Save(product, e)); var product2 = new Product(); product2.Load(store.Query().For<Product>(6)); Assert.Equal(product.Id, product2.Id); Assert.Equal(product.Version, product2.Version); var events = store.Query().For<Product>(5).OfType<Product.PublishedEvent>(); Assert.Equal(3, events.Count()); Console.WriteLine("For product 5, of type published:"); foreach (var e in events) { Console.WriteLine("\t" + e); } events = store.Query().For<Product>().OfType<Product.PublishedEvent>(); Assert.Equal(5, events.Count()); Console.WriteLine(); Console.WriteLine("For all products, of type published:"); foreach (var e in events) { Console.WriteLine("\t" + e); } events = store.Query().For<Product>(); Assert.Equal(7, events.Count()); Console.WriteLine(); Console.WriteLine("For all products, all event types:"); foreach (var e in events) { Console.WriteLine("\t" + e); } events = store.Query().OfType<Product.CreatedEvent>(); Assert.Equal(2, events.Count()); Console.WriteLine(); Console.WriteLine("Products created events:"); foreach (var e in events) { Console.WriteLine("\t" + e); } //product.Load(store.Events.For<Product>(23)); //var player = new DomainEventPlayer(store); //player.Observe<ProductPublishedEvent>(); //player.Replay(from: null, to: null); //store.Events.Where( //store.Events.Where(x => x.AggregateType == "Product" && // x.EventType == "Published"); }
public MemoryStreamFactory(MemoryEventStore eventStore) { _eventStore = eventStore; }