public void CanMigrateEvents()
{
// Arrange
var container = CreateContainer();
var eventStore = container.Resolve<EventStore>();
var aggregate = new Aggregate();
aggregate.Change();
WithEventStore(container, session => session.Store(aggregate));
// Act
var eventMigrators = new List<IEventMigrator>
{
// deliberately wrong order here
new SecondEventMigrator(),
new FirstEventMigrator()
};
eventStore.MigrateEvents(eventMigrators);
// Assert
History history = null;
WithEventStore(container, session => history = session.Load<History>(aggregate.Id));
Assert.That(history.Events, Is.Not.Null);
Assert.That(history.Events.Count, Is.EqualTo(4));
Assert.That(history.Events[0], Is.EqualTo("Created1A"));
Assert.That(history.Events[1], Is.EqualTo("Created2"));
Assert.That(history.Events[2], Is.EqualTo("Changed1A"));
Assert.That(history.Events[3], Is.EqualTo("Changed2"));
}
public void MergesEvents()
{
// Arrange
var container = CreateContainer();
var eventStore = container.Resolve<EventStore>();
var documentStore = container.Resolve<IDocumentStore>();
// store base aggregate
var aggregate = new Aggregate();
using (var documentSession = documentStore.OpenSession())
{
var eventStoreSession = eventStore.OpenSession(documentStore, documentSession);
eventStoreSession.Store(aggregate);
eventStoreSession.SaveChanges();
}
using (var firstSession = documentStore.OpenSession())
using (var secondSession = documentStore.OpenSession())
{
// use optimistic concurrency
// this will enable merging of events
secondSession.Advanced.UseOptimisticConcurrency = true;
var firstEventStoreSession = eventStore.OpenSession(documentStore, firstSession);
// Act
// make change to left side
firstEventStoreSession.Load<Aggregate>(aggregate.Id).FirstAction();
var secondEventStoreSession = eventStore.OpenSession(documentStore, secondSession);
// make change to right side
secondEventStoreSession.Load<Aggregate>(aggregate.Id).SecondAction();
firstEventStoreSession.SaveChanges();
secondEventStoreSession.SaveChanges();
}
// Assert
// expect merged result
using (var documentSession = documentStore.OpenSession())
{
var eventStoreSession = eventStore.OpenSession(documentStore, documentSession);
var mergedAggregate = eventStoreSession.Load<Aggregate>(aggregate.Id);
// Assert.That(mergedAggregate.GetHistory().Length, Is.EqualTo(3));
}
}
public void LoadsSecondFromUnitOfWork()
{
// Arrange
var aggregate = new Aggregate();
var container = CreateContainer();
var eventStore = container.Resolve<EventStore>();
var eventStoreSession = eventStore.OpenSession(
container.Resolve<IDocumentStore>(), container.Resolve<IDocumentSession>());
eventStoreSession.Store(aggregate);
// Act
var secondAggregate = eventStoreSession.Load<Aggregate>(aggregate.Id);
// Assert
Assert.That(secondAggregate, Is.SameAs(aggregate));
}
public void RespectRavenConventions()
{
// Arrange
var container = new WindsorContainer();
container.Register(Component.For<IDocumentStore>().UsingFactoryMethod(CreateDocumentStore));
container.Register(
Component.For<IDocumentSession>().UsingFactoryMethod(k => k.Resolve<IDocumentStore>().OpenSession()).LifestyleTransient());
container.Install(EventStoreInstaller.FromAssembly(Assembly.GetExecutingAssembly()));
var eventStore = container.Resolve<EventStore>();
// Act
var eventStoreSession = eventStore.OpenSession(
container.Resolve<IDocumentStore>(), container.Resolve<IDocumentSession>());
var aggregate = new Aggregate();
eventStoreSession.Store(aggregate);
eventStoreSession.SaveChanges();
// Assert
Assert.That(aggregate.Id, Is.EqualTo("EventStreams-Aggregates-1"));
}
public void CanSaveChangesSeveralTimes()
{
// Arrange
var handler = new AggregateHandler();
var container = CreateContainer(new[] { handler });
var aggregate = new Aggregate();
aggregate.Change();
var eventStore = container.Resolve<EventStore>();
var eventStoreSession = eventStore.OpenSession(
container.Resolve<IDocumentStore>(), container.Resolve<IDocumentSession>());
eventStoreSession.Store(aggregate);
// Act
eventStoreSession.SaveChanges();
Assert.That(aggregate.GetUncommittedChanges().Length, Is.EqualTo(0));
Assert.That(handler.Changes, Is.EqualTo(1));
aggregate.Change();
eventStoreSession.SaveChanges();
// Assert
Assert.That(handler.Changes, Is.EqualTo(2));
}
public void PlacesAggregateInUnitOfWork()
{
// Arrange
var aggregate = new Aggregate();
var container = CreateContainer();
WithEventStore(container, session => session.Store(aggregate));
// Act
WithEventStore(container, session =>
{
var a = session.Load<Aggregate>(aggregate.Id);
a.Change();
});
// Assert
var documentStore = container.Resolve<IDocumentStore>();
using (var session = documentStore.OpenSession())
{
var es = container.Resolve<EventStore>().OpenSession(documentStore, session);
var a = es.Load<Aggregate>(aggregate.Id);
Assert.That(a, Is.Not.Null);
Assert.That(a.Changed, Is.True);
}
}
