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