public void DisposeDoNotInitialize()
{
var sfp = new SessionFactoryProvider();
Assert.That(Spying.Logger <SessionFactoryProvider>().Execute(sfp.Dispose).WholeMessage,
Text.DoesNotContain("Initialize a new session factory"));
}
public void AutoCriarBancoDeDados()
{
var sessionFactoryProvider = new SessionFactoryProvider();
var sessionProvider = new SessionProvider(sessionFactoryProvider);
sessionProvider.GetCurrentSession();
sessionFactoryProvider.AutoCriarBancoDeDados();
}
static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
var schemaCreator = new SchemaCreator();
schemaCreator.CreateSchema();
var container = new WindsorContainer()
.AddFacility <WcfFacility>()
.AddFacility <FactorySupportFacility>()
.Register(SessionEndPoint)
.Register(Component.For <IProductRepository>().ImplementedBy <ProductRepository>())
.Register(Service <IProductModel, ProductModel>(9595));
var nhConfigurator = new DefaultSessionFactoryConfigurationProvider();
var sfp = new SessionFactoryProvider(nhConfigurator);
container.Register(Component.For <ISessionFactoryProvider>().Instance(sfp));
container.Register(Component.For <ISessionWrapper>().ImplementedBy <SessionWrapper>());
container.Register(Component.For <ISessionFactory>().Instance(sfp.GetFactory(null)));
IoC.RegisterResolver(new WindsorDependencyResolver(container));
CurrentSessionContext.Wrapper = container.Resolve <ISessionWrapper>();
Console.WriteLine("Server started");
Console.ReadLine();
schemaCreator.CreateSchema();
}
public void inserirPizza()
{
var provider = new SessionFactoryProvider();
var sessionProvider = new SessionProvider(provider);
var sessaoAtual = sessionProvider.GetCurrentSession();
var pizza = new Pizza {
Nome = "Muçarela"
};
sessaoAtual.Save(pizza);
var ingrediente1 = new Ingrediente {
Nome = "Queijo"
};
var ingrediente2 = new Ingrediente {
Nome = "Oregano"
};
var ingrediente3 = new Ingrediente {
Nome = "Tomate"
};
pizza.AcrescentarIngrediente(ingrediente1);
pizza.AcrescentarIngrediente(ingrediente2);
pizza.AcrescentarIngrediente(ingrediente3);
sessaoAtual.Save(ingrediente1);
sessaoAtual.Save(ingrediente2);
sessaoAtual.Save(ingrediente3);
sessaoAtual.Clear();
Assert.AreEqual("Muçarela", sessaoAtual.Get <Pizza>(pizza.Id).Nome);
Assert.AreEqual(3, sessaoAtual.Get <Pizza>(pizza.Id).Ingredientes.Count);
}
public void InitializeShouldLog()
{
var sfp = new SessionFactoryProvider();
Assert.That(Spying.Logger <SessionFactoryProvider>().Execute(sfp.Initialize).WholeMessage,
Text.Contains("Initialize a new session factory"));
}
public void ShouldLogMultiConfigurationIgnored()
{
var sfp = new SessionFactoryProvider(new MultiConfStub());
Assert.That(Spying.Logger <SessionFactoryProvider>().Execute(sfp.Initialize).WholeMessage,
Text.Contains("More than one configurations are available"));
}
public override void GlobalContext()
{
base.GlobalContext();
_sessionFactoryProvider = new SessionFactoryProvider();
_dataBaseFile = FileHelper.GenerateTemporaryFileName();
_sessionFactory = _sessionFactoryProvider.InitalizeSessionFactoryFor(_dataBaseFile);
}
public override void Load()
{
Bind <IDateProvider>().To <DateProvider>().InSingletonScope();
Bind <ISessionFactory>()
.ToMethod(context =>
SessionFactoryProvider.SqliteSessionFactory("HourGlass.db")).InSingletonScope();
Bind <IHourGlassRepo>().To <HourGlassRepo>().InSingletonScope();
}
public override void GlobalContext()
{
base.GlobalContext();
sut = new SessionFactoryProvider();
_dataBaseFile = FileHelper.GenerateTemporaryFileName();
_sessionFactory = sut.InitalizeSessionFactoryFor(_dataBaseFile);
_content = Encoding.UTF8.GetBytes("content");
}
private static void AddConfigurationProvider(this IServiceCollection services)
{
if (configProvider == null)
{
configProvider = new SessionFactoryProvider();
services.AddSingleton <ISessionFactoryProvider>(f => configProvider);
}
}
static void Main(string[] args)
{
string configPath = args.Length > 1 ? args[1] : ConfigurationLoader.DefaultConfigFilePath;
var configuration = new ConfigurationLoader(new JsonDeserializer(), configPath).Load();
var sessionFactory = new SessionFactoryProvider().Create(true, configuration.DatabaseFilepath);
var session = sessionFactory.OpenSession();
Console.Out.WriteLine("Database schema exported");
}
public void ShouldInitializeOnlyOneTime()
{
var sfp = new SessionFactoryProvider();
Assert.That(sfp.GetFactory(null), Is.Not.Null);
Assert.That(Spying.Logger <SessionFactoryProvider>().Execute(sfp.Initialize).WholeMessage,
Text.DoesNotContain("Initialize a new session factory"));
}
public override void Load()
{
// Provide the ISessionFactory for DI, someone will need to provide ISession with the proper scoping
Kernel.Bind <NHibernate.ISessionFactory>()
.ToMethod(c => SessionFactoryProvider.GetSessionFactory())
.InSingletonScope();
// Load all of the NHibernate based repositories into the kernel
Kernel.Bind <IEntityRepository <Product> >().To <NHibernateProductsRepository>();
}
/// <summary>
/// Configures the NHibernate session.
/// </summary>
/// <param name="configurationProvider">The configuration provider.</param>
/// <param name="container">The container.</param>
protected override void ConfigureNHibernateSession(IConfigurationProvider configurationProvider, IContainer container)
{
var configuration = configurationProvider.Configure().GetEnumerator().Current;
configuration.SetProperty(Environment.CurrentSessionContextClass, typeof(WebSessionContext).AssemblyQualifiedName);
var sessionFactoryProvider = new SessionFactoryProvider(configurationProvider);
sessionFactoryProvider.Initialize();
container.Configure(x => x.For <ISessionFactoryProvider>().Singleton().Use(sessionFactoryProvider));
}
protected void CreateContainer()
{
if (container == null)
{
ContainerBuilder builder = new ContainerBuilder();
builder.RegisterAssemblyTypes(Assembly.GetCallingAssembly()).Where(x => x.Name.EndsWith("Repository")).AsImplementedInterfaces();
//SessionFactoryProvider.BuildSessionFactory().OpenSession();
builder.Register <ISession>(x => SessionFactoryProvider.BuildSessionFactory().OpenSession()).InstancePerLifetimeScope();
container = builder.Build();
}
}
public void ShouldReturnDefaultPropertiesForSqlServer()
{
// Arrange
var provider = new SessionFactoryProvider();
// Act
var defaults = provider.DefaultProperties;
// Assert
Assert.Equal("NHibernate.Connection.DriverConnectionProvider", defaults.Single(p => p.Key == "hibernate.connection.provider").Value);
Assert.Equal("NHibernate.Driver.SqlClientDriver", defaults.Single(p => p.Key == "hibernate.connection.driver_class").Value);
Assert.Equal("NHibernate.Dialect.MsSql2008Dialect", defaults.Single(p => p.Key == "hibernate.dialect").Value);
}
public static WindsorContainer InicializarContainer()
{
var container = new WindsorContainer();
container.Register(Component.For <IAdministradorServico>().ImplementedBy <AdministradorServico>());
container.Register(Component.For <IPizzaDAO>().ImplementedBy <PizzaDAO>());
container.Register(Component.For <IIngredienteDAO>().ImplementedBy <IngredienteDAO>());
container.Register(Component.For <IBancoDadosCreator>().ImplementedBy <BancoDadosCreator>());
var sessionFactory = new SessionFactoryProvider();
container.Register(Component.For <SessionProvider>().Instance(new SessionProvider(sessionFactory)).LifeStyle.Singleton);
return(container);
}
public override void Configure(IWindsorContainer container)
{
container.AddFacility <PersistenceConversationFacility>();
container.AddFacility <FactorySupportFacility>();
NHibernate.Cfg.Environment.BytecodeProvider = new EnhancedBytecode(container);
var nhConfigurator = new DefaultSessionFactoryConfigurationProvider();
//sessionFactory part
var sessionFactoryProvider = new SessionFactoryProvider(nhConfigurator);
container.Register(Component.For <ISessionFactory>().UsingFactoryMethod(() => sessionFactoryProvider.GetFactory(null)));
container.Register(Component.For <ISessionFactoryImplementor>().UsingFactoryMethod(() => (ISessionFactoryImplementor)sessionFactoryProvider.GetFactory(null)));
//uNhAddIns part
container.Register(Component.For <ISessionFactoryProvider>().Instance(sessionFactoryProvider));
container.Register(Component.For <ISessionWrapper>().ImplementedBy <SessionWrapper>());
container.Register(Component.For <IConversationFactory>().ImplementedBy <DefaultConversationFactory>());
container.Register(Component.For <IConversationsContainerAccessor>().ImplementedBy <NhConversationsContainerAccessor>());
nhConfigurator.BeforeConfigure += (sender, e) =>
{
var nhCfg = e.Configuration;
nhCfg.RegisterEntityNameResolver();
RegisterProperties(nhCfg);
RegisterMappings(nhCfg);
RegisterListeners(nhCfg);
RegisterEntityCaches(nhCfg);
SchemaMetadataUpdater.QuoteTableAndColumns(nhCfg);
e.Configured = true; // prevent read from Nhibernate.cfg
};
nhConfigurator.AfterConfigure += (sender, e) =>
{
var nhCfg = e.Configuration;
//TryUpdateSchema
var value = ConfigurationManager.AppSettings["SchemaUpdate"];
if (value.IsNotNullOrEmpty() && value.Equals(bool.TrueString, StringComparison.OrdinalIgnoreCase))
{
new SchemaUpdate(nhCfg).Execute(false, true);
}
};
base.Configure(container);
}
public override void GlobalContext()
{
base.GlobalContext();
_sessionFactoryProvider = new SessionFactoryProvider();
if (string.IsNullOrEmpty(_dataBaseFile))
{
_dataBaseFile = FileHelper.GenerateTemporaryFileName();
}
_sessionFactory = _sessionFactoryProvider.InitalizeSessionFactoryFor(_dataBaseFile);
this.LogDebug("Database file {0}", _dataBaseFile);
}
static void InitializeNHSessionManagement()
{
container.AddFacility <PersistenceConversationFacility>();
var nhConfigurator = new DefaultSessionFactoryConfigurationProvider();
nhConfigurator.AfterConfigure += ((sender, e) => new SchemaExport(e.Configuration).Create(false, true));
var sfp = new SessionFactoryProvider(nhConfigurator);
container.Register(Component.For <ISessionFactoryProvider>().Instance(sfp));
// I prefer to use uNhAddIns.LinFuAdapters.SessionWrapper , the discussion: http://groups.google.com/group/unhaddins/browse_thread/thread/e548a6f6a8a444fd
container.Register(Component.For <ISessionWrapper>().ImplementedBy <SessionWrapper>());
container.Register(Component.For <ISessionFactory>().Instance(sfp.GetFactory(null)));
container.Register(Component.For <IConversationFactory>().ImplementedBy <DefaultConversationFactory>());
container.Register(Component.For <IConversationsContainerAccessor>().ImplementedBy <NhConversationsContainerAccessor>());
}
public void TestHbm()
{
using (var lifetime = IocConfig.Container.BeginLifetimeScope())
{
#if DEBUG
if (File.Exists("hbm.xml"))
{
File.Delete("hbm.xml");
}
File.AppendAllText("hbm.xml", SessionFactoryProvider.BuildMappingsXml());
#endif
Assert.IsTrue(2 + 2 == 2 * 2);
}
}
private static void InitializeAndRegisterPersistenceStuff(IContainer container)
{
var configurationProvider = container.GetInstance <IConfigurationProvider> ();
var configuration = configurationProvider.Configure().GetEnumerator().Current;
configuration.SetProperty(
Environment.CurrentSessionContextClass,
"uNhAddIns.SessionEasier.Contexts.ThreadLocalSessionContext, uNhAddIns");
var sessionFactoryProvider = new SessionFactoryProvider(configurationProvider);
sessionFactoryProvider.Initialize();
container.Configure(x => x.For <ISessionFactoryProvider> ().Singleton().Use(sessionFactoryProvider));
container.Configure(x => x.For <ISessionProvider> ().Use <SessionProvider> ());
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
ModelBinders.Binders.Add(typeof(UserLoadParams), new UserLoadParamsBinder());
InitIoC();
SessionFactoryProvider.InitConfig(ConfigurationManager.AppSettings.Get("ConnectionString"));
Container.Register(Component.For <ISession>()
.UsingFactoryMethod(() => SessionFactoryProvider.SessionFactory.OpenSession())
.LifestylePerWebRequest());
}
public void ShouldExecuteDisposeOlnyOne()
{
SessionFactoryProvider sfp;
ISessionFactory sf1;
bool disposed = false;
using (sfp = new SessionFactoryProvider())
{
sfp.BeforeCloseSessionFactory += ((sender, e) => disposed = true);
sf1 = sfp.GetFactory(null);
}
Assert.That(disposed);
Assert.That(sf1.IsClosed, "The session-factory should be closed.");
disposed = false;
sfp.Dispose();
Assert.That(!disposed);
}
public void ShouldHasOnlyOneInstanceOfFactory()
{
var sfp = new SessionFactoryProvider();
ISessionFactory sf1 = sfp.GetFactory(null);
ISessionFactory sf2 = sfp.GetFactory(null);
Assert.That(sf1, Is.Not.Null);
Assert.That(ReferenceEquals(sf1, sf2));
Assert.That(sfp.Count(), Is.EqualTo(1));
IEnumerator en = ((IEnumerable)sfp).GetEnumerator();
int i = 0;
while (en.MoveNext())
{
i++;
}
Assert.That(i, Is.EqualTo(1));
}
public void Persistence_test_passes_for_a_correctly_mapped_entity(SampleEntity entity,
SessionFactoryProvider factoryProvider,
SchemaCreator schemaCreator)
{
var factory = factoryProvider.GetSessionFactory();
var result = TestPersistence.UsingSessionFactory(factory)
.WithSetup(s =>
{
schemaCreator.CreateSchema(s.Connection);
})
.WithEntity(entity)
.WithEqualityRule(r => r.ForAllOtherProperties());
Assert.That(() =>
{
Assert.That(result, Persisted.Successfully());
}, Throws.Nothing);
}
public static WindsorContainer InicializarContainer()
{
//if (_container == null)
//{
_container = new WindsorContainer();
_container.Register(Component.For <IBancoDadosCreator>().ImplementedBy <BancoDadosCreator>());
_container.Register(Component.For <IAdministradorServico>().ImplementedBy <AdministradorServico>());
_container.Register(Component.For <IAutorRepositorio>().ImplementedBy <AutorRepositorio>());
_container.Register(Component.For <ILivroRepositorio>().ImplementedBy <LivroRepositorio>());
_container.Register(Component.For <IEstanteRepositorio>().ImplementedBy <EstanteRepositorio>());
_container.Register(Component.For <IPrateleiraRepositorio>().ImplementedBy <PrateleiraRepositorio>());
var sessionFactoryProvider = new SessionFactoryProvider();
_container.Register(Component.For <SessionProvider>().LifeStyle.Singleton.Instance(new SessionProvider(sessionFactoryProvider)));
//}
return(_container);
}
public void Persistence_test_fails_for_an_entity_which_cannot_be_saved(EntityWithBadlyNamedProperty entity,
SessionFactoryProvider factoryProvider,
SchemaCreator schemaCreator)
{
var factory = factoryProvider.GetSessionFactory();
var result = TestPersistence.UsingSessionFactory(factory)
.WithSetup(s =>
{
schemaCreator.CreateSchema(s.Connection);
})
.WithEntity(entity)
.WithEqualityRule(r => r.ForAllOtherProperties());
Assert.That(() =>
{
Assert.That(result, Persisted.Successfully());
}, Throws.InstanceOf <AssertionException>());
Assert.That(result?.SaveException, Is.Not.Null);
}
public void Persistence_test_fails_for_an_incorrectly_mapped_entity(EntityWithUnmappedProperty entity,
SessionFactoryProvider factoryProvider,
SchemaCreator schemaCreator)
{
var factory = factoryProvider.GetSessionFactory();
var result = TestPersistence.UsingSessionFactory(factory)
.WithSetup(s =>
{
schemaCreator.CreateSchema(s.Connection);
})
.WithEntity(entity)
.WithEqualityRule(r => r.ForAllOtherProperties());
Assert.That(() =>
{
Assert.That(result, Persisted.Successfully());
}, Throws.InstanceOf <AssertionException>());
Assert.That(result?.EqualityResult?.RuleResults?.Where(x => !x.Passed).Count(), Is.EqualTo(1));
}
public void Persistence_test_fails_when_the_setup_throws_an_exception(SampleEntity entity,
SessionFactoryProvider factoryProvider,
SchemaCreator schemaCreator)
{
var factory = factoryProvider.GetSessionFactory();
var result = TestPersistence.UsingSessionFactory(factory)
.WithSetup(s =>
{
schemaCreator.CreateSchema(s.Connection);
throw new InvalidOperationException("Sample exception");
})
.WithEntity(entity)
.WithEqualityRule(r => r.ForAllOtherProperties());
Assert.That(() =>
{
Assert.That(result, Persisted.Successfully());
}, Throws.InstanceOf <AssertionException>());
Assert.That(result?.SetupException, Is.Not.Null);
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
Environment.BytecodeProvider = new EnhancedBytecode(container);
var nhConfigurator = new DefaultSessionFactoryConfigurationProvider();
nhConfigurator.BeforeConfigure += (sender, e) => ValidatorInitializer.Initialize(e.Configuration);
var sfp = new SessionFactoryProvider(nhConfigurator);
container.Register(Component.For <ISessionFactoryProvider>()
.Instance(sfp));
container.Register(Component.For <ISessionFactory>()
.Forward <ISessionFactoryImplementor>()
.UsingFactoryMethod(() => container.Resolve <ISessionFactoryProvider>().GetFactory(null)));
container.Register(Component.For <ISessionWrapper>().ImplementedBy <SessionWrapper>());
container.Register(Component.For <IConversationFactory>().ImplementedBy <DefaultConversationFactory>());
container.Register(Component.For <IConversationsContainerAccessor>().ImplementedBy <NhConversationsContainerAccessor>());
}
