public void RETREIVE_EVENT_STREAM_FOR_AN_EXISTING_DOCUMENT()
{
MongoEventStore store = new MongoEventStore(client);
var events = store.LoadEventStream(id);
Assert.IsFalse(events == null);
}
private static MongoEventStore CreateStore(
List <StreamConfiguration> streams,
MongoFake db = null,
BatchIDGenerator idGenerator = null,
bool preserveLog = false,
bool callUpgrade = true
)
{
db = db ?? new MongoFake();
idGenerator = idGenerator ?? new LoggingIDGenerator();
ConfigureSerialization(new GuidSerializer(BsonType.Binary));
MongoEventStore store = new MongoEventStore(
db,
new EventStoreSettings(streams),
idGenerator
);
if (callUpgrade)
{
store.Upgrade().Wait();
}
if (!preserveLog)
{
db.Log.Clear();
}
return(store);
}
public async Task Test_events()
{
using (var eventStore = new MongoEventStore(_mongoClient, DatabaseName))
{
var eventStoreTestSuit = new EventStoreTestSuit(eventStore, new ProjectionSerializer(_bsonSerializer));
var aggregate = await eventStoreTestSuit.EventTestsAsync();
using (var projectionRepository = new MongoProjectionRepository(_mongoClient, DatabaseName))
{
var projection = await projectionRepository.GetAsync <BarProjection>(nameof(BarProjection), aggregate.Id);
projection.Id.Should().Be(aggregate.Id);
projection.LastText.Should().Be(aggregate.LastText);
projection.UpdatedAt.ToString("G").Should().Be(aggregate.UpdatedAt.ToString("G"));
projection.Messages.Count.Should().Be(aggregate.Messages.Count);
}
using (var projectionRepository = new MongoProjectionRepository <BarProjection>(_mongoClient, DatabaseName))
{
var projections = await projectionRepository.FindAsync(e => e.Id == aggregate.Id);
projections.Count().Should().BeGreaterOrEqualTo(1);
}
}
}
public void RETREIVE_ALL_EVENTS()
{
MongoEventStore store = new MongoEventStore(client);
var events = store.LoadEvents(0, int.MaxValue);
Assert.IsFalse(events.Count == 0);
}
public async Task Projection_is_rebuilt_by_denormalizer()
{
//Need to create an aggregate here.
var serializer = new EventSerializer(new BsonTextSerializer());
DenormAggregate aggregate;
using (var eventStore = new MongoEventStore(_mongoClient, _defaultSettings))
{
aggregate = new DenormAggregate(Guid.NewGuid());
for (int i = 0; i < 10; i++)
{
aggregate.DoThing("Thing_" + i);
}
var session = new Session(new LoggerFactory(), eventStore, new EventPublisher(StubEventRouter.Ok()), serializer);
session.Add(aggregate);
await session.CommitAsync();
}
var projectionRepository = new MongoProjectionRepository(_mongoClient, _defaultSettings);
using (var eventStore = new MongoEventStore(_mongoClient, _defaultSettings))
{
var testDenormalizer = new TestDenormalizer(projectionRepository, eventStore, serializer);
await testDenormalizer.RebuildAsync();
}
var projection = await projectionRepository.RetrieveAsync <TestProjection>("TestDenormalizedProjection");
projection.LastThing.Should().Be(aggregate.LastThing);
}
public void Should_use_default_settings()
{
using (var eventStore = new MongoEventStore(_mongoClient, new MongoEventStoreSettings()))
{
eventStore.Settings.EventsCollectionName.Should().Be(_defaultSettings.EventsCollectionName);
eventStore.Settings.Database.Should().Be("EventStore");
}
}
internal EventStoreConfigurator RegisterMongoEventStore(IContainer container)
{
var appSettings = container.GetInstance<AppSettings>();
var mongoEvents = new MongoInstance(appSettings.EventsConnectionString);
var eventStore = new MongoEventStore(mongoEvents.GetDatabase(), EventStoreSettings.GetDefault());
container.Configure(config => config.For<IEventStore>().Singleton().Use(eventStore));
return this;
}
public async Task Test_snapshot()
{
using (var eventStore = new MongoEventStore(_mongoClient, DatabaseName))
{
var eventStoreTestSuit = new EventStoreTestSuit(eventStore, new ProjectionSerializer(_bsonSerializer));
await eventStoreTestSuit.SnapshotTestsAsync();
}
}
public async Task When_any_exception_be_thrown()
{
using (var eventStore = new MongoEventStore(_mongoClient, DatabaseName))
{
var eventStoreTestSuit = new EventStoreTestSuit(eventStore, new ProjectionSerializer(_bsonSerializer));
await eventStoreTestSuit.DoSomeProblemAsync();
}
}
public async Task Events_are_stored()
{
using (var eventStore = new MongoEventStore(_mongoClient, _defaultSettings))
{
var eventStoreTestSuit = new EventStoreTestSuit(eventStore);
await eventStoreTestSuit.EventTestsAsync();
}
}
public async Task SubAggregate_events_are_stored_with_primary_aggregate()
{
using (var eventStore = new MongoEventStore(_mongoClient, _defaultSettings))
{
var eventStoreTestSuit = new EventStoreTestSuit(eventStore);
await eventStoreTestSuit.SubAggregateEventTestsAsync();
}
}
public async Task When_any_exception_is_thrown()
{
using (var eventStore = new MongoEventStore(_mongoClient, _defaultSettings))
{
var eventStoreTestSuit = new EventStoreTestSuit(eventStore);
await eventStoreTestSuit.DoSomeProblemAsync();
}
}
public async Task When_any_exception_be_thrown()
{
using (var embeddedMongoDbServer = new EmbeddedMongoDbServer())
{
var eventStore = new MongoEventStore(embeddedMongoDbServer.Client, DatabaseName);
var eventStoreTestSuit = new EventStoreTestSuit(eventStore);
await eventStoreTestSuit.DoSomeProblemAsync();
}
}
public void Should_use_default_settings()
{
var defaultSettings = new MongoEventStoreSetttings();
using (var eventStore = new MongoEventStore(_mongoClient, DatabaseName))
{
eventStore.Setttings.EventsCollectionName.Should().Be(defaultSettings.EventsCollectionName);
eventStore.Setttings.SnapshotsCollectionName.Should().Be(defaultSettings.SnapshotsCollectionName);
}
}
public async Task Test_events()
{
using (var embeddedMongoDbServer = new EmbeddedMongoDbServer())
{
var eventStore = new MongoEventStore(embeddedMongoDbServer.Client, DatabaseName);
var eventStoreTestSuit = new EventStoreTestSuit(eventStore);
await eventStoreTestSuit.EventTestsAsync();
}
}
public void Should_create_database()
{
using (var eventStore = new MongoEventStore(_mongoClient, _defaultSettings))
{
var database = eventStore.Client.GetDatabase(_databaseName);
database.Should().NotBeNull();
eventStore.Settings.Database.Should().Be(_databaseName);
}
}
public void Should_use_default_settings()
{
var defaultSettings = new MongoEventStoreSetttings();
using (EmbeddedMongoDbServer embeddedMongoDbServer = new EmbeddedMongoDbServer())
{
var eventStore = new MongoEventStore(embeddedMongoDbServer.Client, DatabaseName);
eventStore.Setttings.EventsCollectionName.Should().Be(defaultSettings.EventsCollectionName);
eventStore.Setttings.SnapshotsCollectionName.Should().Be(defaultSettings.SnapshotsCollectionName);
}
}
public void STORE_NEW_EVENTS_ON_NEW_DOCUMENT()
{
MongoEventStore store = new MongoEventStore(client);
Events.SampleEvent _event = new Events.SampleEvent {
Message = "Test", id = id
};
IList <IEvent> events = new List <IEvent>();
events.Add(_event);
store.AppendToStream(id, 1, events);
}
public void MongoEventStore_Deserializes_Events()
{
var id = Guid.NewGuid();
var events = new List <EventStream>
{
new EventStream
{
AggregateRootId = id,
DateCreated = DateTime.Now,
EventData = new List <DomainEvent> {
new AccountDebitedEvent(Guid.NewGuid(), 100)
{
Sequence = 2
}
},
Id = ObjectId.GenerateNewId(),
SequenceStart = 2,
SequenceEnd = 2
},
new EventStream
{
AggregateRootId = id,
DateCreated = DateTime.Now,
EventData = new List <DomainEvent> {
new AccountCreatedEvent(Guid.NewGuid(), 100)
{
Sequence = 1
}
},
Id = ObjectId.GenerateNewId(),
SequenceStart = 1,
SequenceEnd = 1
}
};
var database = new Mock <IMongoRepository>();
database.Setup(db => db.GetEventStream(It.IsAny <Guid>(), It.IsAny <long>())).Returns(events);
var store = new MongoEventStore
{
GetRepository = () => database.Object
};
var eventStream = store.GetEvents(id, 1).ToList();
Assert.AreEqual(2, eventStream.Count());
Assert.AreEqual(1, eventStream[0].Sequence);
Assert.AreEqual(2, eventStream[1].Sequence);
Assert.IsInstanceOf <AccountCreatedEvent>(eventStream[0]);
Assert.IsInstanceOf <AccountDebitedEvent>(eventStream[1]);
}
/// <summary>
/// Creates and registers an <see cref="MongoEventStore"/> implementation to use
/// for this application.
/// </summary>
/// <param name="configuration">The <see cref="ProcessorConfiguration"/> for which to register the created trace writer.</param>
/// <param name="connectionString">Thye connection string.</param>
/// <param name="databaseName">The database name.</param>
/// <returns>The <see cref="MongoEventStore"/> which was created and registered.</returns>
public static MongoEventStore EnableMongoEventSourcing(this ProcessorConfiguration configuration, string connectionString, string databaseName)
{
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
MongoEventStore eventStore = new MongoEventStore(connectionString, databaseName);
configuration.Services.Replace(typeof(IEventStore), eventStore);
return(eventStore);
}
public void Should_use_custom_settings()
{
var customSettings = new MongoEventStoreSettings
{
EventsCollectionName = "MyEvents",
Database = DatabaseName
};
using (var eventStore = new MongoEventStore(_mongoClient, customSettings))
{
eventStore.Settings.EventsCollectionName.Should().Be(customSettings.EventsCollectionName);
}
}
public void Should_create_database()
{
using (EmbeddedMongoDbServer embeddedMongoDbServer = new EmbeddedMongoDbServer())
{
var eventStore = new MongoEventStore(embeddedMongoDbServer.Client, DatabaseName);
var database = embeddedMongoDbServer.Client.GetDatabase(DatabaseName);
database.Should().NotBeNull();
eventStore.Database.Should().Be(DatabaseName);
}
}
protected static void ConfigureSerialization2(IBsonSerializer streamIDSerializer = null)
{
SerializationTypeRegistry types = new SerializationTypeRegistry();
ContractTypeSerializerOptions options = new ContractTypeSerializerOptions();
options.Serializers.Add(new DX.Contracts.Serializers.IDSerializer());
ContractTypeSerializer contractTypeSerializer = new ContractTypeSerializer(types, options);
MongoEventStore.ConfigureSerialization(
new MongoEventStoreSerializatonSettings(
streamIDSerializer ?? new GuidSerializer(BsonType.Binary),
new ContractTypeSerializerAdapter <object, IEvent>(contractTypeSerializer),
new ContractTypeSerializerAdapter <object, DefaultEventMetadata>(contractTypeSerializer),
new TypeNameResolver(types)));
}
public void Should_use_custom_settings()
{
var customSettings = new MongoEventStoreSetttings
{
EventsCollectionName = "MyEvents",
SnapshotsCollectionName = "MySnapshots"
};
using (EmbeddedMongoDbServer embeddedMongoDbServer = new EmbeddedMongoDbServer())
{
var eventStore = new MongoEventStore(embeddedMongoDbServer.Client, DatabaseName, customSettings);
eventStore.Setttings.EventsCollectionName.Should().Be(customSettings.EventsCollectionName);
eventStore.Setttings.SnapshotsCollectionName.Should().Be(customSettings.SnapshotsCollectionName);
}
}
public void INSERT_HUNDRED_EVENTS()
{
MongoEventStore store = new MongoEventStore(client);
client.GetServer().GetDatabase("EventStore").Drop();
Enumerable.
Range(1, 100).
ToList().
ForEach(i =>
{
var newid = new Events.SampleID(i);
Events.SampleEvent _event = new Events.SampleEvent {
Message = "Test", id = newid
};
IList <IEvent> events = new List <IEvent>();
events.Add(_event);
store.AppendToStream(newid, 1, events);
});
}
public void Should_persist_aggregate_events()
{
var eventStore = new MongoEventStore();
var repository = new EventStoreRepository <Account>(eventStore);
var account = new Account();
account.Deposit(100);
account.Withdraw(75);
repository.Save(account);
account = repository.GetById(account.Id, id => new Account(id));
Assert.AreEqual(25, account.Balance);
var stream = eventStore.OpenStream(account.Id);
Assert.AreEqual(account.Version, stream.Revision);
}
protected override void Load(ContainerBuilder builder)
{
var storeType = Configuration.GetValue <string>("squidex:eventStore:type");
if (string.IsNullOrWhiteSpace(storeType))
{
throw new ConfigurationException("You must specify the store type in the 'squidex:eventStore:type' configuration section.");
}
if (string.Equals(storeType, "MongoDb", StringComparison.OrdinalIgnoreCase))
{
var databaseName = Configuration.GetValue <string>("squidex:eventStore:mongoDb:databaseName");
if (string.IsNullOrWhiteSpace(databaseName))
{
throw new ConfigurationException("You must specify the MongoDB database name in the 'squidex:eventStore:mongoDb:databaseName' configuration section.");
}
var connectionString = Configuration.GetValue <string>("squidex:eventStore:mongoDb:connectionString");
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new ConfigurationException("You must specify the MongoDB connection string in the 'squidex:eventStore:mongoDb:connectionString' configuration section.");
}
builder.Register(c =>
{
var mongoDbClient = new MongoClient(connectionString);
var mongoDatabase = mongoDbClient.GetDatabase(databaseName);
var eventStore = new MongoEventStore(mongoDatabase, c.Resolve <IEventNotifier>(), c.Resolve <IClock>());
return(eventStore);
})
.As <IExternalSystem>()
.As <IEventStore>()
.SingleInstance();
}
else
{
throw new ConfigurationException($"Unsupported store type '{storeType}' for key 'squidex:eventStore:type', supported: MongoDb.");
}
}
public void Upgrade(MongoEventStore store)
{
MongoFake db = default;
GIVEN["an empty DB and one configured stream"] = () => store = CreateStore(
new List <StreamConfiguration> {
new StreamConfiguration(typeof(Order), "order")
},
db = new MongoFake(),
new PresetIDGenerator(),
callUpgrade: false
);
When["calling Upgrade"] = () => store.Upgrade();
THEN["the Events collection is created with index on StreamID"] = () => db.Log.Should().Contain(b => b
.CreateCollection("Events")
.CreateIndex("Events", "StreamID"));
GIVEN["a proper configuration"] = () => {
store = CreateStore(
new List <StreamConfiguration> {
new StreamConfiguration(typeof(Customer), "customer"),
new StreamConfiguration(typeof(Order), "order"),
new StreamConfiguration(typeof(OrderProcessor), "order_processor")
},
db,
new PresetIDGenerator(),
callUpgrade: false,
preserveLog: true
);
};
When["calling Upgrade"] = () => store.Upgrade();
THEN["the missing collections are created"] = () => {
db.Log.Should().Contain(b => b
.CreateCollection("customer_Info")
.CreateCollection("order_processor_Info"));
};
}
static void Main(string[] args)
{
try
{
MongoEventStore store = new MongoEventStore("");
store.Save(null);
//var p = store.Get();
var o = store.Get(new Guid("089373bb-900b-49f2-967b-ee3db8f00c25"), 1);
Console.Write(o);
Console.Read();
}
catch (Exception ex)
{
throw ex;
}
Console.WriteLine("Hello World!");
}
public void MongoEventStore_Serialized_Events()
{
var database = new Mock <IMongoRepository>();
database.Setup(db => db.InsertEvents(It.IsAny <EventStream>()));
var store = new MongoEventStore
{
GetRepository = () => database.Object
};
var events = new List <DomainEvent>
{
new AccountCreatedEvent(Guid.NewGuid(), 100),
new AccountDebitedEvent(Guid.NewGuid(), 50)
};
store.Insert(Guid.NewGuid(), events);
database.Verify(db => db.InsertEvents(It.IsAny <EventStream>()), Times.Once);
}
public void GetAll(MongoEventStore store, IEventStoreTransaction tx, List <EventBatch> exp, List <EventBatch> act)
{
MongoFake db = default;
GIVEN["a configured store"] = () => store = CreateStore(
new List <StreamConfiguration> {
new StreamConfiguration(typeof(Customer), "customer"),
new StreamConfiguration(typeof(Order), "order")
},
db = new MongoFake());
Given["a transaction"] = async() => tx = store.UseTransaction(await db.StartTransactionAsync());
WHEN["storing some streams"] = () => {
exp = new List <EventBatch>();
Guid customerID = Guid.NewGuid();
Save(Order.CreateOrderWithProducts());
Save(Customer.CreateCustomer(customerID));
Save(Order.CreateOrderWithProducts());
Save(CreateStream <Customer>(customerID, new Customer.Promoted()));
void Save <T>(EventBatch <T> batch)
{
tx.Save(batch).Wait();
exp.Add(batch);
};
};
AND["calling GetAll"] = () => {
db.BatchSize = 2;
act = tx.GetAll().Result.ToList().Result;
};
THEN["all stored events are returned in original order"] = () =>
act.Should().BeEquivalentTo(exp, o => o.WithStrictOrdering());
}
