protected override void Compose()
{
base.Compose();
Builder.Services.AddTransient <ISqlSyntaxProvider, SqlCeSyntaxProvider>();
Builder.Services.AddTransient(factory => PublishedSnapshotService);
Builder.Services.AddTransient(factory => DefaultCultureAccessor);
Builder.WithCollectionBuilder <DataEditorCollectionBuilder>()
.Clear()
.Add(() => Builder.TypeLoader.GetDataEditors());
Builder.WithCollectionBuilder <UmbracoApiControllerTypeCollectionBuilder>()
.Add(Builder.TypeLoader.GetUmbracoApiControllers());
Builder.Services.AddUnique(f =>
{
if (Options.Database == UmbracoTestOptions.Database.None)
{
return(TestObjects.GetDatabaseFactoryMock());
}
var lazyMappers = new Lazy <IMapperCollection>(f.GetRequiredService <IMapperCollection>);
var factory = new UmbracoDatabaseFactory(f.GetRequiredService <ILogger <UmbracoDatabaseFactory> >(), f.GetRequiredService <ILoggerFactory>(), GetDbConnectionString(), GetDbProviderName(), lazyMappers, TestHelper.DbProviderFactoryCreator, f.GetRequiredService <DatabaseSchemaCreatorFactory>());
return(factory);
});
}
public SqlMainDomLock(
ILoggerFactory loggerFactory,
IOptions <GlobalSettings> globalSettings,
IOptionsMonitor <ConnectionStrings> connectionStrings,
IDbProviderFactoryCreator dbProviderFactoryCreator,
IMainDomKeyGenerator mainDomKeyGenerator,
DatabaseSchemaCreatorFactory databaseSchemaCreatorFactory,
NPocoMapperCollection npocoMappers)
{
// unique id for our appdomain, this is more unique than the appdomain id which is just an INT counter to its safer
_lockId = Guid.NewGuid().ToString();
_logger = loggerFactory.CreateLogger <SqlMainDomLock>();
_globalSettings = globalSettings;
_sqlServerSyntax = new SqlServerSyntaxProvider(_globalSettings);
_dbFactory = new UmbracoDatabaseFactory(
loggerFactory.CreateLogger <UmbracoDatabaseFactory>(),
loggerFactory,
_globalSettings,
new MapperCollection(() => Enumerable.Empty <BaseMapper>()),
dbProviderFactoryCreator,
databaseSchemaCreatorFactory,
npocoMappers,
connectionStrings.CurrentValue.UmbracoConnectionString.ConnectionString);
MainDomKey = MainDomKeyPrefix + "-" + mainDomKeyGenerator.GenerateKey();
}
public SqlMainDomLock(
ILogger <SqlMainDomLock> logger,
ILoggerFactory loggerFactory,
IOptions <GlobalSettings> globalSettings,
IOptionsMonitor <ConnectionStrings> connectionStrings,
IDbProviderFactoryCreator dbProviderFactoryCreator,
IHostingEnvironment hostingEnvironment,
DatabaseSchemaCreatorFactory databaseSchemaCreatorFactory,
NPocoMapperCollection npocoMappers,
string connectionStringName)
{
// unique id for our appdomain, this is more unique than the appdomain id which is just an INT counter to its safer
_lockId = Guid.NewGuid().ToString();
_logger = logger;
_globalSettings = globalSettings;
_sqlServerSyntax = new SqlServerSyntaxProvider(_globalSettings);
_hostingEnvironment = hostingEnvironment;
_dbFactory = new UmbracoDatabaseFactory(
loggerFactory.CreateLogger <UmbracoDatabaseFactory>(),
loggerFactory,
_globalSettings,
new MapperCollection(() => Enumerable.Empty <BaseMapper>()),
dbProviderFactoryCreator,
databaseSchemaCreatorFactory,
npocoMappers,
connectionStringName);
MainDomKey = MainDomKeyPrefix + "-" + (Environment.MachineName + MainDom.GetMainDomId(_hostingEnvironment)).GenerateHash <SHA1>();
}
protected override void Compose()
{
base.Compose();
Composition.Register <ISqlSyntaxProvider, SqlCeSyntaxProvider>();
Composition.Register(factory => PublishedSnapshotService);
Composition.Register(factory => DefaultCultureAccessor);
Composition.WithCollectionBuilder <DataEditorCollectionBuilder>()
.Clear()
.Add(() => Composition.TypeLoader.GetDataEditors());
Composition.RegisterUnique(f =>
{
if (Options.Database == UmbracoTestOptions.Database.None)
{
return(TestObjects.GetDatabaseFactoryMock());
}
var logger = f.GetInstance <ILogger>();
var mappers = f.GetInstance <IMapperCollection>();
var factory = new UmbracoDatabaseFactory(GetDbConnectionString(), GetDbProviderName(), logger, new Lazy <IMapperCollection>(() => mappers));
factory.ResetForTests();
return(factory);
});
}
public IScopeProvider GetScopeProvider(ILoggerFactory loggerFactory, FileSystems fileSystems = null, IUmbracoDatabaseFactory databaseFactory = null)
{
var globalSettings = Options.Create(new GlobalSettings());
var connectionString = ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName].ConnectionString;
var connectionStrings = Options.Create(new ConnectionStrings {
UmbracoConnectionString = new ConfigConnectionString(Constants.System.UmbracoConnectionName, connectionString)
});
var coreDebugSettings = new CoreDebugSettings();
if (databaseFactory == null)
{
// var mappersBuilder = new MapperCollectionBuilder(Current.Container); // FIXME:
// mappersBuilder.AddCore();
// var mappers = mappersBuilder.CreateCollection();
var mappers = Current.Factory.GetRequiredService <IMapperCollection>();
databaseFactory = new UmbracoDatabaseFactory(
loggerFactory.CreateLogger <UmbracoDatabaseFactory>(),
loggerFactory,
globalSettings,
connectionStrings,
new Lazy <IMapperCollection>(() => mappers),
TestHelper.DbProviderFactoryCreator,
new DatabaseSchemaCreatorFactory(Mock.Of <ILogger <DatabaseSchemaCreator> >(), loggerFactory, new UmbracoVersion(), Mock.Of <IEventAggregator>()));
}
fileSystems ??= new FileSystems(loggerFactory, TestHelper.IOHelper, globalSettings, TestHelper.GetHostingEnvironment());
var coreDebug = TestHelper.CoreDebugSettings;
var mediaFileManager = Mock.Of <MediaFileManager>();
var eventAggregator = Mock.Of <IEventAggregator>();
return(new ScopeProvider(databaseFactory, fileSystems, Options.Create(coreDebugSettings), mediaFileManager, loggerFactory.CreateLogger <ScopeProvider>(), loggerFactory, NoAppCache.Instance, eventAggregator));
}
private IUmbracoDatabase GetSqlCeDatabase(string cstr, ILogger logger)
{
var f = new UmbracoDatabaseFactory(
cstr,
Constants.DatabaseProviders.SqlCe,
logger,
new Lazy <IMapperCollection>(() => new MapperCollection(Enumerable.Empty <BaseMapper>())));
return(f.CreateDatabase());
}
public SqlMainDomLock(ILogger logger)
{
// unique id for our appdomain, this is more unique than the appdomain id which is just an INT counter to its safer
_lockId = Guid.NewGuid().ToString();
_logger = logger;
_dbFactory = new UmbracoDatabaseFactory(
Constants.System.UmbracoConnectionName,
_logger,
new Lazy <IMapperCollection>(() => new Persistence.Mappers.MapperCollection(Enumerable.Empty <BaseMapper>())));
}
// FIXME: should run on LocalDb same as NPoco tests!
private IUmbracoDatabase GetSqlServerDatabase(ILogger logger)
{
IScopeProvider f = null;
var l = new Lazy <IScopeProvider>(() => f);
var factory = new UmbracoDatabaseFactory(
"server=.\\SQLExpress;database=YOURDB;user id=YOURUSER;password=YOURPASS",
Constants.DatabaseProviders.SqlServer,
logger,
new Lazy <IMapperCollection>(() => new MapperCollection(Enumerable.Empty <BaseMapper>())));
return(factory.CreateDatabase());
}
public void Cant_Connect_To_SqlDatabase_Because_Of_Network()
{
const string connectionString = @"server=.\SQLEXPRESS;database=EmptyForTest;user id=umbraco;password=umbraco";
const string providerName = Constants.DbProviderNames.SqlServer;
var factory = new UmbracoDatabaseFactory(connectionString, providerName, Mock.Of <ILogger>(), new Lazy <IMapperCollection>(() => Mock.Of <IMapperCollection>()));
using (var database = factory.CreateDatabase())
{
Assert.Throws <SqlException>(
() => database.Fetch <dynamic>("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES"));
}
}
public void Cant_Connect_To_SqlDatabase_With_Invalid_User()
{
const string connectionString = @"server=.\SQLEXPRESS;database=EmptyForTest;user id=x;password=umbraco";
const string providerName = Constants.DbProviderNames.SqlServer;
var factory = new UmbracoDatabaseFactory(Mock.Of <ILogger <UmbracoDatabaseFactory> >(), NullLoggerFactory.Instance, connectionString, providerName, new Lazy <IMapperCollection>(() => Mock.Of <IMapperCollection>()), TestHelper.DbProviderFactoryCreator, TestHelper.DatabaseSchemaCreatorFactory);
using (var database = factory.CreateDatabase())
{
Assert.Throws <SqlException>(
() => database.Fetch <dynamic>("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES"));
}
}
public SqlMainDomLock(ILogger logger, string connectionStringName = Constants.System.UmbracoConnectionName)
{
// unique id for our appdomain, this is more unique than the appdomain id which is just an INT counter to its safer
_lockId = Guid.NewGuid().ToString();
_logger = logger;
_dbFactory = new UmbracoDatabaseFactory(
connectionStringName,
_logger,
new Lazy <IMapperCollection>(() => new MapperCollection(Enumerable.Empty <BaseMapper>())));
_lockTimeout = TimeSpan.FromMilliseconds(GlobalSettings.GetSqlWriteLockTimeoutFromConfigFile(logger));
}
public IScopeProvider GetScopeProvider(ILogger logger, FileSystems fileSystems = null, IUmbracoDatabaseFactory databaseFactory = null)
{
if (databaseFactory == null)
{
//var mappersBuilder = new MapperCollectionBuilder(Current.Container); // fixme
//mappersBuilder.AddCore();
//var mappers = mappersBuilder.CreateCollection();
var mappers = Current.Factory.GetInstance <IMapperCollection>();
databaseFactory = new UmbracoDatabaseFactory(Constants.System.UmbracoConnectionName, logger, new Lazy <IMapperCollection>(() => mappers));
}
fileSystems = fileSystems ?? new FileSystems(Current.Factory, logger);
var scopeProvider = new ScopeProvider(databaseFactory, fileSystems, logger);
return(scopeProvider);
}
private static IFactory MockFactory(Action <Mock <IFactory> > setup = null)
{
// FIXME: use IUmbracoDatabaseFactory vs UmbracoDatabaseFactory, clean it all up!
var mock = new Mock <IFactory>();
var logger = Mock.Of <ILogger>();
var f = new UmbracoDatabaseFactory(logger, new Lazy <IMapperCollection>(() => new MapperCollection(Enumerable.Empty <BaseMapper>())));
var fs = new FileSystems(mock.Object, logger);
var p = new ScopeProvider(f, fs, logger);
mock.Setup(x => x.GetInstance(typeof(ILogger))).Returns(logger);
mock.Setup(x => x.GetInstance(typeof(IProfilingLogger))).Returns(new ProfilingLogger(Mock.Of <ILogger>(), Mock.Of <IProfiler>()));
mock.Setup(x => x.GetInstance(typeof(IUmbracoDatabaseFactory))).Returns(f);
mock.Setup(x => x.GetInstance(typeof(IScopeProvider))).Returns(p);
setup?.Invoke(mock);
return(mock.Object);
}
private static IServiceProvider MockFactory(Action <Mock <IServiceProvider> > setup = null)
{
// FIXME: use IUmbracoDatabaseFactory vs UmbracoDatabaseFactory, clean it all up!
var mock = new Mock <IServiceProvider>();
NullLoggerFactory loggerFactory = NullLoggerFactory.Instance;
ILogger logger = loggerFactory.CreateLogger("GenericLogger");
var globalSettings = new GlobalSettings();
var connectionStrings = new ConnectionStrings();
var mapperCollection = new NPocoMapperCollection(() => new[] { new NullableDateMapper() });
var f = new UmbracoDatabaseFactory(
loggerFactory.CreateLogger <UmbracoDatabaseFactory>(),
loggerFactory,
Options.Create(globalSettings),
Mock.Of <IOptionsMonitor <ConnectionStrings> >(x => x.CurrentValue == connectionStrings),
new MapperCollection(() => Enumerable.Empty <BaseMapper>()),
TestHelper.DbProviderFactoryCreator,
new DatabaseSchemaCreatorFactory(loggerFactory.CreateLogger <DatabaseSchemaCreator>(), loggerFactory, new UmbracoVersion(), Mock.Of <IEventAggregator>()),
mapperCollection);
var fs = new FileSystems(loggerFactory, IOHelper, Options.Create(globalSettings), Mock.Of <IHostingEnvironment>());
var coreDebug = new CoreDebugSettings();
var mediaFileManager = new MediaFileManager(
Mock.Of <IFileSystem>(),
Mock.Of <IMediaPathScheme>(),
Mock.Of <ILogger <MediaFileManager> >(),
Mock.Of <IShortStringHelper>(),
Mock.Of <IServiceProvider>(),
Options.Create(new ContentSettings()));
IEventAggregator eventAggregator = Mock.Of <IEventAggregator>();
var scopeProvider = new ScopeProvider(f, fs, Options.Create(coreDebug), mediaFileManager, loggerFactory.CreateLogger <ScopeProvider>(), loggerFactory, NoAppCache.Instance, eventAggregator);
mock.Setup(x => x.GetService(typeof(ILogger))).Returns(logger);
mock.Setup(x => x.GetService(typeof(ILogger <ComponentCollection>))).Returns(loggerFactory.CreateLogger <ComponentCollection>);
mock.Setup(x => x.GetService(typeof(ILoggerFactory))).Returns(loggerFactory);
mock.Setup(x => x.GetService(typeof(IProfilingLogger))).Returns(new ProfilingLogger(loggerFactory.CreateLogger <ProfilingLogger>(), Mock.Of <IProfiler>()));
mock.Setup(x => x.GetService(typeof(IUmbracoDatabaseFactory))).Returns(f);
mock.Setup(x => x.GetService(typeof(IScopeProvider))).Returns(scopeProvider);
setup?.Invoke(mock);
return(mock.Object);
}
public void StandaloneTest()
{
IFactory factory = null;
// clear
foreach (var file in Directory.GetFiles(Path.Combine(IOHelper.MapPath("~/App_Data")), "NuCache.*"))
{
File.Delete(file);
}
// settings
// reset the current version to 0.0.0, clear connection strings
ConfigurationManager.AppSettings[Constants.AppSettings.ConfigurationStatus] = "";
// FIXME: we need a better management of settings here (and, true config files?)
// create the very basic and essential things we need
var logger = new ConsoleLogger();
var profiler = new LogProfiler(logger);
var profilingLogger = new ProfilingLogger(logger, profiler);
var appCaches = new AppCaches(); // FIXME: has HttpRuntime stuff?
var databaseFactory = new UmbracoDatabaseFactory(logger, new Lazy <IMapperCollection>(() => factory.GetInstance <IMapperCollection>()));
var typeLoader = new TypeLoader(appCaches.RuntimeCache, IOHelper.MapPath("~/App_Data/TEMP"), profilingLogger);
var mainDom = new SimpleMainDom();
var runtimeState = new RuntimeState(logger, null, null, new Lazy <IMainDom>(() => mainDom), new Lazy <IServerRegistrar>(() => factory.GetInstance <IServerRegistrar>()));
// create the register and the composition
var register = RegisterFactory.Create();
var composition = new Composition(register, typeLoader, profilingLogger, runtimeState);
composition.RegisterEssentials(logger, profiler, profilingLogger, mainDom, appCaches, databaseFactory, typeLoader, runtimeState);
// create the core runtime and have it compose itself
var coreRuntime = new CoreRuntime();
coreRuntime.Compose(composition);
// determine actual runtime level
runtimeState.DetermineRuntimeLevel(databaseFactory, logger);
Console.WriteLine(runtimeState.Level);
// going to be Install BUT we want to force components to be there (nucache etc)
runtimeState.Level = RuntimeLevel.Run;
var composerTypes = typeLoader.GetTypes <IComposer>() // all of them
.Where(x => !x.FullName.StartsWith("Umbraco.Tests.")) // exclude test components
.Where(x => x != typeof(WebInitialComposer) && x != typeof(WebFinalComposer)); // exclude web runtime
var composers = new Composers(composition, composerTypes, Enumerable.Empty <Attribute>(), profilingLogger);
composers.Compose();
// must registers stuff that WebRuntimeComponent would register otherwise
// FIXME: UmbracoContext creates a snapshot that it does not register with the accessor
// and so, we have to use the UmbracoContextPublishedSnapshotAccessor
// the UmbracoContext does not know about the accessor
// else that would be a catch-22 where they both know about each other?
//composition.Register<IPublishedSnapshotAccessor, TestPublishedSnapshotAccessor>(Lifetime.Singleton);
composition.Register <IPublishedSnapshotAccessor, UmbracoContextPublishedSnapshotAccessor>(Lifetime.Singleton);
composition.Register <IUmbracoContextAccessor, TestUmbracoContextAccessor>(Lifetime.Singleton);
composition.Register <IVariationContextAccessor, TestVariationContextAccessor>(Lifetime.Singleton);
composition.Register <IDefaultCultureAccessor, TestDefaultCultureAccessor>(Lifetime.Singleton);
composition.Register <ISiteDomainHelper>(_ => Mock.Of <ISiteDomainHelper>(), Lifetime.Singleton);
composition.Register(_ => Mock.Of <IImageUrlGenerator>(), Lifetime.Singleton);
composition.RegisterUnique(f => new DistributedCache());
composition.WithCollectionBuilder <UrlProviderCollectionBuilder>().Append <DefaultUrlProvider>();
composition.RegisterUnique <IDistributedCacheBinder, DistributedCacheBinder>();
composition.RegisterUnique <IExamineManager>(f => ExamineManager.Instance);
composition.RegisterUnique <IUmbracoContextFactory, UmbracoContextFactory>();
composition.RegisterUnique <IMacroRenderer, MacroRenderer>();
composition.RegisterUnique <MediaUrlProviderCollection>(_ => new MediaUrlProviderCollection(Enumerable.Empty <IMediaUrlProvider>()));
// initialize some components only/individually
composition.WithCollectionBuilder <ComponentCollectionBuilder>()
.Clear()
.Append <DistributedCacheBinderComponent>();
// configure
composition.Configs.Add(SettingsForTests.GetDefaultGlobalSettings);
composition.Configs.Add(SettingsForTests.GetDefaultUmbracoSettings);
// create and register the factory
Current.Factory = factory = composition.CreateFactory();
// instantiate and initialize components
var components = factory.GetInstance <ComponentCollection>();
// do stuff
Console.WriteLine(runtimeState.Level);
// install
if (true || runtimeState.Level == RuntimeLevel.Install)
{
var path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var file = databaseFactory.Configured ? Path.Combine(path, "UmbracoNPocoTests.sdf") : Path.Combine(path, "Umbraco.sdf");
if (File.Exists(file))
{
File.Delete(file);
}
// create the database file
// databaseBuilder.ConfigureEmbeddedDatabaseConnection() can do it too,
// but then it wants to write the connection string to web.config = bad
var connectionString = databaseFactory.Configured ? databaseFactory.ConnectionString : "Data Source=|DataDirectory|\\Umbraco.sdf;Flush Interval=1;";
using (var engine = new SqlCeEngine(connectionString))
{
engine.CreateDatabase();
}
//var databaseBuilder = factory.GetInstance<DatabaseBuilder>();
//databaseFactory.Configure(DatabaseBuilder.EmbeddedDatabaseConnectionString, Constants.DbProviderNames.SqlCe);
//databaseBuilder.CreateDatabaseSchemaAndData();
if (!databaseFactory.Configured)
{
databaseFactory.Configure(DatabaseBuilder.EmbeddedDatabaseConnectionString, Constants.DbProviderNames.SqlCe);
}
var scopeProvider = factory.GetInstance <IScopeProvider>();
using (var scope = scopeProvider.CreateScope())
{
var creator = new DatabaseSchemaCreator(scope.Database, logger);
creator.InitializeDatabaseSchema();
scope.Complete();
}
}
// done installing
runtimeState.Level = RuntimeLevel.Run;
components.Initialize();
// instantiate to register events
// should be done by Initialize?
// should we invoke Initialize?
_ = factory.GetInstance <IPublishedSnapshotService>();
// at that point, Umbraco can run!
// though, we probably still need to figure out what depends on HttpContext...
var contentService = factory.GetInstance <IContentService>();
var content = contentService.GetById(1234);
Assert.IsNull(content);
// create a document type and a document
var contentType = new ContentType(-1)
{
Alias = "ctype", Name = "ctype"
};
factory.GetInstance <IContentTypeService>().Save(contentType);
content = new Content("test", -1, contentType);
contentService.Save(content);
// assert that it is possible to get the document back
content = contentService.GetById(content.Id);
Assert.IsNotNull(content);
Assert.AreEqual("test", content.Name);
// need an UmbracoCOntext to access the cache
// FIXME: not exactly pretty, should not depend on HttpContext
var httpContext = Mock.Of <HttpContextBase>();
var umbracoContextFactory = factory.GetInstance <IUmbracoContextFactory>();
var umbracoContextReference = umbracoContextFactory.EnsureUmbracoContext(httpContext);
var umbracoContext = umbracoContextReference.UmbracoContext;
// assert that there is no published document
var pcontent = umbracoContext.Content.GetById(content.Id);
Assert.IsNull(pcontent);
// but a draft document
pcontent = umbracoContext.Content.GetById(true, content.Id);
Assert.IsNotNull(pcontent);
Assert.AreEqual("test", pcontent.Name());
Assert.IsTrue(pcontent.IsDraft());
// no published URL
Assert.AreEqual("#", pcontent.Url());
// now publish the document + make some unpublished changes
contentService.SaveAndPublish(content);
content.Name = "testx";
contentService.Save(content);
// assert that snapshot has been updated and there is now a published document
pcontent = umbracoContext.Content.GetById(content.Id);
Assert.IsNotNull(pcontent);
Assert.AreEqual("test", pcontent.Name());
Assert.IsFalse(pcontent.IsDraft());
// but the URL is the published one - no draft URL
Assert.AreEqual("/test/", pcontent.Url());
// and also an updated draft document
pcontent = umbracoContext.Content.GetById(true, content.Id);
Assert.IsNotNull(pcontent);
Assert.AreEqual("testx", pcontent.Name());
Assert.IsTrue(pcontent.IsDraft());
// and the published document has a URL
Assert.AreEqual("/test/", pcontent.Url());
umbracoContextReference.Dispose();
mainDom.Stop();
components.Terminate();
// exit!
}
