public async Task It_should_return_a_new_one_when_none_was_configured()
{
DocumentStore documentStore = null;
try
{
documentStore = ConfigureEndpointRavenDBPersistence.GetDocumentStore();
RavenSessionTestContext context =
await Scenario.Define <RavenSessionTestContext>(testContext => { })
.WithEndpoint <SharedRavenSessionExtensions>(b => b.When((bus, c) =>
{
var sendOptions = new SendOptions();
sendOptions.RouteToThisEndpoint();
return(bus.Send(new SharedRavenSessionExtensions.GenericMessage(), sendOptions));
}))
.Done(c => c.HandlerWasHit)
.Run();
Assert.IsNotNull(context.RavenSessionFromHandler);
}
finally
{
if (documentStore != null)
{
await ConfigureEndpointRavenDBPersistence.DeleteDatabase(documentStore.Database);
}
}
}
public static PersistenceExtensions <RavenDBPersistence> ResetDocumentStoreSettings(this PersistenceExtensions <RavenDBPersistence> cfg, out TestDatabaseInfo dbInfo)
{
var settings = cfg.GetSettings();
var docStore = ConfigureEndpointRavenDBPersistence.GetDefaultDocumentStore(settings);
settings.Set("RavenDbDocumentStore", null);
dbInfo = new TestDatabaseInfo
{
Urls = docStore.Urls,
Database = docStore.Database
};
return(cfg);
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings)
{
var documentStore = ConfigureEndpointRavenDBPersistence.GetDocumentStore();
databaseName = documentStore.Database;
configuration.UsePersistence <RavenDBPersistence, StorageType.GatewayDeduplication>()
.DoNotSetupDatabasePermissions()
.SetDefaultDocumentStore(documentStore);
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings)
{
var documentStore = ConfigureEndpointRavenDBPersistence.GetDocumentStore();
databaseName = documentStore.Database;
#pragma warning disable 618
configuration.UsePersistence <RavenDBPersistence, StorageType.GatewayDeduplication>()
#pragma warning restore 618
.SetDefaultDocumentStore(documentStore);
return(Task.FromResult(0));
}
public async Task It_should_return_configured_session()
{
DocumentStore documentStore = null;
var createdSessions = new List <IAsyncDocumentSession>();
try
{
documentStore = ConfigureEndpointRavenDBPersistence.GetDocumentStore();
RavenSessionTestContext context =
await Scenario.Define <RavenSessionTestContext>()
.WithEndpoint <SharedRavenSessionExtensions>(b =>
b.CustomConfig(config =>
{
config.UsePersistence <RavenDBPersistence>().UseSharedAsyncSession(_ =>
{
var session = documentStore.OpenAsyncSession();
createdSessions.Add(session);
return(session);
});
})
.When((bus, c) =>
{
var sendOptions = new SendOptions();
sendOptions.RouteToThisEndpoint();
return(bus.Send(new SharedRavenSessionExtensions.GenericMessage(), sendOptions));
}))
.Done(c => c.HandlerWasHit)
.Run();
var injectedSessionId = ((InMemoryDocumentSessionOperations)context.RavenSessionFromHandler).Id;
var found = createdSessions.Cast <InMemoryDocumentSessionOperations>().Any(session => session.Id == injectedSessionId);
Assert.IsTrue(found);
}
finally
{
foreach (var session in createdSessions)
{
session.Dispose();
}
if (documentStore != null)
{
await ConfigureEndpointRavenDBPersistence.DeleteDatabase(documentStore.Database);
}
}
}
public async Task It_should_return_configured_session()
{
DocumentStore documentStore = null;
IAsyncDocumentSession session = null;
try
{
documentStore = ConfigureEndpointRavenDBPersistence.GetDocumentStore();
session = documentStore.OpenAsyncSession();
RavenSessionTestContext context =
await Scenario.Define <RavenSessionTestContext>()
.WithEndpoint <SharedRavenSessionExtensions>(b =>
b.CustomConfig(config =>
{
config.UsePersistence <RavenDBPersistence>().UseSharedAsyncSession(_ => session);
})
.When((bus, c) =>
{
var sendOptions = new SendOptions();
sendOptions.RouteToThisEndpoint();
return(bus.Send(new SharedRavenSessionExtensions.GenericMessage(), sendOptions));
}))
.Done(c => c.HandlerWasHit)
.Run();
Assert.AreSame(session, context.RavenSessionFromHandler);
}
finally
{
if (session != null)
{
session.Dispose();
session = null;
}
if (documentStore != null)
{
await ConfigureEndpointRavenDBPersistence.DeleteDatabase(documentStore.Database);
}
}
}
public Task Cleanup()
{
return(ConfigureEndpointRavenDBPersistence.DeleteDatabase(databaseName));
}
async Task RunTest(Action <ContextDbConfig> configureMultiTenant)
{
var context = await Scenario.Define <Context>(c =>
{
c.Db1 = "Tenant1-" + Guid.NewGuid().ToString("n").Substring(16);
c.Db2 = "Tenant2-" + Guid.NewGuid().ToString("n").Substring(16);
})
.WithEndpoint <MultiTenantEndpoint>(b =>
{
b.CustomConfig((cfg, c) =>
{
cfg.EnableOutbox();
cfg.LimitMessageProcessingConcurrencyTo(1);
cfg.Pipeline.Register(new MessageCountingBehavior(c), "Counts all messages processed");
var settings = cfg.GetSettings();
var defaultStore = ConfigureEndpointRavenDBPersistence.GetDefaultDocumentStore(settings);
c.DefaultDb = defaultStore.Database;
c.DbConfig.DefaultStore = defaultStore;
ConfigureEndpointRavenDBPersistence.CreateDatabase(defaultStore, c.Db1);
ConfigureEndpointRavenDBPersistence.CreateDatabase(defaultStore, c.Db2);
c.DbConfig.PersistenceExtensions = ConfigureEndpointRavenDBPersistence.GetDefaultPersistenceExtensions(settings);
configureMultiTenant(c.DbConfig);
});
async Task SendMessage(IMessageSession session, string messageId, string orderId, string dbName)
{
var msg = new TestMsg
{
OrderId = orderId
};
var opts = new SendOptions();
opts.RouteToThisEndpoint();
opts.SetHeader("RavenDatabaseName", dbName);
opts.SetMessageId(messageId);
await session.Send(msg, opts);
}
b.When(async(session, ctx) =>
{
var msgId1 = Guid.NewGuid().ToString();
var msgId2 = Guid.NewGuid().ToString();
await SendMessage(session, msgId1, "OrderA", ctx.Db1);
await SendMessage(session, msgId1, "OrderA", ctx.Db1);
await SendMessage(session, msgId2, "OrderB", ctx.Db2);
await SendMessage(session, msgId2, "OrderB", ctx.Db2);
});
})
.Done(c => c.MessagesObserved >= 4)
.Run();
await ConfigureEndpointRavenDBPersistence.DeleteDatabase(context.Db1);
await ConfigureEndpointRavenDBPersistence.DeleteDatabase(context.Db2);
Assert.AreEqual(4, context.MessagesObserved);
Assert.AreEqual(2, context.ObservedDbs.Count);
Assert.IsFalse(context.ObservedDbs.Any(db => db == context.DefaultDb));
Assert.Contains(context.Db1, context.ObservedDbs);
Assert.Contains(context.Db2, context.ObservedDbs);
}
