public NhibernateTestSetupHelper(string dataSource, SupportedNHDrivers supportedNhDrivers, string sessionContext, bool executeSchema, FakeFrameworkContext frameworkContext = null, bool useNhProf = false, bool outputMappings = false, bool leaveSessionOpenOnRepositoryDispose = true, bool useSingleSessionForTest = true)
{
_useNhProfiler = useNhProf;
var builder = new NHibernateConfigBuilder(dataSource, "unit-tester", supportedNhDrivers, sessionContext, outputMappings, _useNhProfiler);
NhConfigurationCacheKey cacheKey;
Config = builder.BuildConfiguration(false, out cacheKey, "on_close");
SessionFactory = SessionFactoryCache.GetOrAdd(cacheKey, key => Config.BuildSessionFactory());
SessionForTest = SessionFactory.OpenSession();
var schemaWriter = new StringWriter(new StringBuilder());
if (executeSchema) new SchemaExport(Config).Execute(false, true, false, SessionForTest.Connection, schemaWriter);
FakeFrameworkContext = frameworkContext ?? new FakeFrameworkContext();
//var dataContextFactory = new DataContextFactory(fakeFrameworkContext, SessionForTest, true);
//var readWriteRepositoryUnitOfWorkFactory = new ReadWriteUnitOfWorkFactory();
//var writer = new HiveReadWriteProvider(new HiveProviderSetup(fakeFrameworkContext, "r-unit-tester", new FakeHiveProviderBootstrapper(), null, readWriteRepositoryUnitOfWorkFactory, dataContextFactory));
var providerMetadata = new ProviderMetadata("r-unit-tester", new Uri("tester://"), true, false);
//var schemaRepositoryFactory = new NullProviderSchemaRepositoryFactory(providerMetadata, fakeFrameworkContext);
//var revisionRepositoryFactory = new NullProviderRevisionRepositoryFactory<TypedEntity>(providerMetadata, fakeFrameworkContext);
var revisionSchemaSessionFactory = new NullProviderRevisionRepositoryFactory<EntitySchema>(providerMetadata,
FakeFrameworkContext);
ProviderDependencyHelper helper = null;
if (!useSingleSessionForTest)
{
helper = new DependencyHelper(new NhFactoryHelper(Config, null, leaveSessionOpenOnRepositoryDispose, false, FakeFrameworkContext), providerMetadata);
}
else
{
helper = new DependencyHelper(new NhFactoryHelper(null, SessionForTest, leaveSessionOpenOnRepositoryDispose, false, FakeFrameworkContext), providerMetadata);
}
var revisionRepositoryFactory = new RevisionRepositoryFactory(providerMetadata, FakeFrameworkContext, helper);
var schemaRepositoryFactory = new SchemaRepositoryFactory(providerMetadata, revisionSchemaSessionFactory,
FakeFrameworkContext, helper);
var entityRepositoryFactory = new EntityRepositoryFactory(providerMetadata, revisionRepositoryFactory,
schemaRepositoryFactory, FakeFrameworkContext,
helper);
var readUnitFactory = new ReadonlyProviderUnitFactory(entityRepositoryFactory);
var unitFactory = new ProviderUnitFactory(entityRepositoryFactory);
ProviderSetup = new ProviderSetup(unitFactory, providerMetadata, FakeFrameworkContext, null, 0);
ReadonlyProviderSetup = new ReadonlyProviderSetup(readUnitFactory, providerMetadata, FakeFrameworkContext, null, 0);
Func<AbstractMappingEngine> addTypemapper = () => new ManualMapperv2(new NhLookupHelper(entityRepositoryFactory), providerMetadata);
FakeFrameworkContext.TypeMappers.Add(new Lazy<AbstractMappingEngine, TypeMapperMetadata>(addTypemapper, new TypeMapperMetadata(true)));
}
public IHiveManager GetHiveManager()
{
IFrameworkContext frameworkContext = GetFrameworkContext();
var providerMetadata = new ProviderMetadata("p__nhibernate", new Uri("content://"), true, false);
var builder =
new NHibernateConfigBuilder(
ConfigurationManager.ConnectionStrings["DatabaseConnString"].ConnectionString,
"unit-tester", SupportedNHDrivers.MsSql2008, "call", false, false);
NhConfigurationCacheKey cacheKey;
Configuration config = builder.BuildConfiguration(false, out cacheKey);
var nhHelper = new NhFactoryHelper(config, null, false, false, frameworkContext);
ProviderDependencyHelper dependencyHelper = new DependencyHelper(nhHelper, providerMetadata);
var revisionRepositoryFactory = new RevisionRepositoryFactory(providerMetadata, frameworkContext,
dependencyHelper);
var revisionSchemaSessionFactory = new NullProviderRevisionRepositoryFactory<EntitySchema>(providerMetadata,
frameworkContext);
var schemaRepositoryFactory = new SchemaRepositoryFactory(providerMetadata, revisionSchemaSessionFactory,
frameworkContext, dependencyHelper);
var entityRepositoryFactory = new EntityRepositoryFactory(providerMetadata, revisionRepositoryFactory,
schemaRepositoryFactory, frameworkContext,
dependencyHelper);
ProviderSetup singleWriter = GetWriterProvider(providerMetadata, frameworkContext, entityRepositoryFactory);
ReadonlyProviderSetup singleReader = GetReaderProvider(providerMetadata, revisionRepositoryFactory,
schemaRepositoryFactory, frameworkContext,
dependencyHelper, config);
Func<AbstractMappingEngine> addTypemapper = () => new ManualMapperv2(new NhLookupHelper(entityRepositoryFactory), providerMetadata);
frameworkContext.TypeMappers.Add(new Lazy<AbstractMappingEngine, TypeMapperMetadata>(addTypemapper, new TypeMapperMetadata(true)));
IHiveManager hive = new HiveManager(new[]
{
new ProviderMappingGroup(
"test",
new WildcardUriMatch("content://"),
singleReader,
singleWriter,
frameworkContext)
}, frameworkContext);
return hive;
}
protected virtual AbstractEntityRepository CreateEntityRepository(bool isReadOnly)
{
if (NhDependencyHelper == null)
{
var extra = "(null)";
if (DependencyHelper != null)
{
extra = DependencyHelper.GetType().Name;
if (DependencyHelper.ProviderMetadata != null)
{
extra += " with key " + DependencyHelper.ProviderMetadata.Alias.IfNullOrWhiteSpace("(no key)");
}
}
throw new NullReferenceException("NhDependencyHelper is null and DependencyHelper is " + extra);
}
if (NhDependencyHelper.FactoryHelper == null)
{
throw new NullReferenceException("NhDependencyHelper.FactoryHelper is null");
}
ISession session;
var transaction = NhDependencyHelper.FactoryHelper.GenerateSessionAndTransaction(isReadOnly, out session);
var schemaRepository = NhSchemaRepositoryFactory != null
? NhSchemaRepositoryFactory.GetRepository(transaction, isReadOnly)
: SchemaRepositoryFactory.GetRepository();
var revisionRepository = NhRevisionRepositoryFactory != null
? NhRevisionRepositoryFactory.GetRepository(transaction, isReadOnly)
: RevisionRepositoryFactory.GetRepository();
return(new EntityRepository(ProviderMetadata, schemaRepository, revisionRepository, transaction, session, FrameworkContext, isReadOnly));
}
private ReadonlyProviderSetup GetReaderProvider(ProviderMetadata providerMetadata,
RevisionRepositoryFactory revisionRepositoryFactory,
SchemaRepositoryFactory schemaRepositoryFactory,
IFrameworkContext frameworkContext,
ProviderDependencyHelper dependencyHelper, Configuration config)
{
AbstractReadonlyEntityRepositoryFactory readonlyEntityRepositoryFactory =
new EntityRepositoryFactory(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory,
frameworkContext, dependencyHelper);
var readonlyUnitFactory = new ReadonlyProviderUnitFactory(readonlyEntityRepositoryFactory);
AbstractProviderBootstrapper bootstrapper = new ProviderBootstrapper(config, null);
var singleReader = new ReadonlyProviderSetup(readonlyUnitFactory, providerMetadata, frameworkContext,
bootstrapper, 0);
return singleReader;
}
/// <summary>
/// Handles the disposal of resources. Derived from abstract class <see cref="DisposableObject"/> which handles common required locking logic.
/// </summary>
protected override void DisposeResources()
{
RevisionRepositoryFactory.Dispose();
SchemaRepositoryFactory.Dispose();
DependencyHelper.Dispose();
}
