// internal/virtual for tests (i.e. hack, do not port to netcore)
internal virtual void DetermineRuntimeLevel(IUmbracoDatabaseFactory databaseFactory, IProfilingLogger profilingLogger)
{
using (var timer = profilingLogger.DebugDuration <CoreRuntime>("Determining runtime level.", "Determined."))
{
try
{
_state.DetermineRuntimeLevel(databaseFactory);
profilingLogger.Debug <CoreRuntime>("Runtime level: {RuntimeLevel} - {RuntimeLevelReason}", _state.Level, _state.Reason);
if (_state.Level == RuntimeLevel.Upgrade)
{
profilingLogger.Debug <CoreRuntime>("Configure database factory for upgrades.");
databaseFactory.ConfigureForUpgrade();
}
}
catch
{
_state.Level = RuntimeLevel.BootFailed;
_state.Reason = RuntimeLevelReason.BootFailedOnException;
timer?.Fail();
throw;
}
}
}
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!
}