public void Can_Create_Document_Table()
{
using (var scope = ScopeProvider.CreateScope())
{
var helper = new DatabaseSchemaCreator(scope.Database, Mock.Of <ILogger>());
helper.CreateTable <NodeDto>();
helper.CreateTable <ContentTypeDto>();
helper.CreateTable <ContentDto>();
helper.CreateTable <TemplateDto>();
helper.CreateTable <DocumentDto>();
scope.Complete();
}
}
public void Can_Create_PropertyData_Table()
{
using (var scope = ScopeProvider.CreateScope())
{
var helper = new DatabaseSchemaCreator(scope.Database, _loggerFactory.CreateLogger <DatabaseSchemaCreator>(), _loggerFactory, UmbracoVersion, EventAggregator);
helper.CreateTable <NodeDto>();
helper.CreateTable <ContentTypeDto>();
helper.CreateTable <DataTypeDto>();
helper.CreateTable <PropertyTypeGroupDto>();
helper.CreateTable <PropertyTypeDto>();
helper.CreateTable <PropertyDataDto>();
scope.Complete();
}
}
public void Can_Create_PropertyData_Table()
{
using (var scope = ScopeProvider.CreateScope())
{
var helper = new DatabaseSchemaCreator(scope.Database, Mock.Of <ILogger>());
helper.CreateTable <NodeDto>();
helper.CreateTable <ContentTypeDto>();
helper.CreateTable <DataTypeDto>();
helper.CreateTable <PropertyTypeGroupDto>();
helper.CreateTable <PropertyTypeDto>();
helper.CreateTable <PropertyDataDto>();
scope.Complete();
}
}
/// <summary>
/// Returns the <see cref="DatabaseSchemaResult"/> for the database
/// </summary>
/// <param name="database"></param>
/// <param name="logger"></param>
/// <returns></returns>
public static DatabaseSchemaResult ValidateSchema(this IUmbracoDatabase database, ILogger logger)
{
if (database is null)
{
throw new ArgumentNullException(nameof(database));
}
if (logger is null)
{
throw new ArgumentNullException(nameof(logger));
}
var dbSchema = new DatabaseSchemaCreator(database, logger);
var databaseSchemaValidationResult = dbSchema.ValidateSchema();
return(databaseSchemaValidationResult);
}
private void RebuildSchemaFirstTime(TestDbMeta meta)
{
_databaseFactory.Configure(meta.ConnectionString, Constants.DatabaseProviders.SqlServer);
using (var database = (UmbracoDatabase)_databaseFactory.CreateDatabase())
{
database.LogCommands = true;
using (NPoco.ITransaction transaction = database.GetTransaction())
{
var schemaCreator = new DatabaseSchemaCreator(database, _loggerFactory.CreateLogger <DatabaseSchemaCreator>(), _loggerFactory, new UmbracoVersion(), Mock.Of <IEventAggregator>());
schemaCreator.InitializeDatabaseSchema();
transaction.Complete();
_cachedDatabaseInitCommands = database.Commands.ToArray();
}
}
}
public void DatabaseSchemaCreation_Produces_DatabaseSchemaResult_With_Zero_Errors()
{
DatabaseSchemaResult result;
using (ScopeProvider.CreateScope(autoComplete: true))
{
var schema = new DatabaseSchemaCreator(
ScopeAccessor.AmbientScope.Database,
LoggerFactory.CreateLogger <DatabaseSchemaCreator>(),
LoggerFactory,
UmbracoVersion,
EventAggregator,
Mock.Of <IOptionsMonitor <InstallDefaultDataSettings> >(x =>
x.CurrentValue == new InstallDefaultDataSettings()));
schema.InitializeDatabaseSchema();
result = schema.ValidateSchema(DatabaseSchemaCreator._orderedTables);
}
// Assert
Assert.That(result.Errors.Count, Is.EqualTo(0));
}
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!
}
private void DoUnattendedInstall(IUmbracoDatabaseFactory databaseFactory)
{
// unattended install is not enabled
if (RuntimeOptions.InstallUnattended == false)
{
return;
}
var localVersion = UmbracoVersion.LocalVersion; // the local, files, version
var codeVersion = _state.SemanticVersion; // the executing code version
// local version and code version is not equal, an unattended install cannot be performed
if (localVersion != codeVersion)
{
return;
}
// no connection string set
if (databaseFactory.Configured == false)
{
return;
}
// create SQL CE database if not existing and database provider is SQL CE
if (databaseFactory.ProviderName == Constants.DbProviderNames.SqlCe)
{
var dataSource = new SqlCeConnectionStringBuilder(databaseFactory.ConnectionString).DataSource;
var dbFilePath = dataSource.Replace("|DataDirectory|", AppDomain.CurrentDomain.GetData("DataDirectory").ToString());
if (File.Exists(dbFilePath) == false)
{
var engine = new SqlCeEngine(databaseFactory.ConnectionString);
engine.CreateDatabase();
}
}
var tries = 5;
var connect = false;
for (var i = 0;;)
{
connect = databaseFactory.CanConnect;
if (connect || ++i == tries)
{
break;
}
Logger.Debug <CoreRuntime>("Could not immediately connect to database, trying again.");
Thread.Sleep(1000);
}
// could not connect to the database
if (connect == false)
{
return;
}
using (var database = databaseFactory.CreateDatabase())
{
var hasUmbracoTables = database.IsUmbracoInstalled(Logger);
// database has umbraco tables, assume Umbraco is already installed
if (hasUmbracoTables)
{
return;
}
// all conditions fulfilled, do the install
Logger.Info <CoreRuntime>("Starting unattended install.");
try
{
database.BeginTransaction();
var creator = new DatabaseSchemaCreator(database, Logger);
creator.InitializeDatabaseSchema();
database.CompleteTransaction();
// Emit an event that unattended install completed
// Then this event can be listened for and create an unattended user
UnattendedInstalled?.Invoke(this, new UnattendedInstallEventArgs());
Logger.Info <CoreRuntime>("Unattended install completed.");
}
catch (Exception ex)
{
Logger.Error <CoreRuntime>(ex, "Error during unattended install.");
database.AbortTransaction();
throw new UnattendedInstallException(
"The database configuration failed with the following message: " + ex.Message
+ "\n Please check log file for additional information (can be found in '/App_Data/Logs/')");
}
}
}
private void DoUnattendedInstall(IUmbracoDatabaseFactory databaseFactory)
{
// unattended install is not enabled
if (RuntimeOptions.InstallUnattended == false)
{
return;
}
var localVersion = UmbracoVersion.LocalVersion; // the local, files, version
var codeVersion = _state.SemanticVersion; // the executing code version
// local version and code version is not equal, an unattended install cannot be performed
if (localVersion != codeVersion)
{
return;
}
// no connection string set
if (databaseFactory.Configured == false)
{
return;
}
var tries = 5;
var connect = false;
for (var i = 0;;)
{
connect = databaseFactory.CanConnect;
if (connect || ++i == tries)
{
break;
}
Logger.Debug <CoreRuntime>("Could not immediately connect to database, trying again.");
Thread.Sleep(1000);
}
// could not connect to the database
if (connect == false)
{
return;
}
using (var database = databaseFactory.CreateDatabase())
{
var hasUmbracoTables = database.IsUmbracoInstalled(Logger);
// database has umbraco tables, assume Umbraco is already installed
if (hasUmbracoTables)
{
return;
}
// all conditions fulfilled, do the install
Logger.Info <CoreRuntime>("Starting unattended install.");
try
{
database.BeginTransaction();
var creator = new DatabaseSchemaCreator(database, Logger);
creator.InitializeDatabaseSchema();
database.CompleteTransaction();
Logger.Info <CoreRuntime>("Unattended install completed.");
}
catch (Exception ex)
{
Logger.Error <CoreRuntime>(ex, "Error during unattended install.");
database.AbortTransaction();
throw new UnattendedInstallException(
"The database configuration failed with the following message: " + ex.Message
+ "\n Please check log file for additional information (can be found in '/App_Data/Logs/')");
}
}
}
public Task HandleAsync(RuntimeUnattendedInstallNotification notification, CancellationToken cancellationToken)
{
// unattended install is not enabled
if (_unattendedSettings.Value.InstallUnattended == false)
{
return(Task.CompletedTask);
}
// no connection string set
if (_databaseFactory.Configured == false)
{
return(Task.CompletedTask);
}
_runtimeState.DetermineRuntimeLevel();
if (_runtimeState.Reason == RuntimeLevelReason.InstallMissingDatabase)
{
_dbProviderFactoryCreator.CreateDatabase(_databaseFactory.ProviderName, _databaseFactory.ConnectionString);
}
bool connect;
try
{
for (var i = 0; ;)
{
connect = _databaseFactory.CanConnect;
if (connect || ++i == 5)
{
break;
}
_logger.LogDebug("Could not immediately connect to database, trying again.");
Thread.Sleep(1000);
}
}
catch (Exception ex)
{
_logger.LogInformation(ex, "Error during unattended install.");
var innerException = new UnattendedInstallException("Unattended installation failed.", ex);
_runtimeState.Configure(Core.RuntimeLevel.BootFailed, Core.RuntimeLevelReason.BootFailedOnException, innerException);
return(Task.CompletedTask);
}
// could not connect to the database
if (connect == false)
{
return(Task.CompletedTask);
}
IUmbracoDatabase database = null;
try
{
using (database = _databaseFactory.CreateDatabase())
{
var hasUmbracoTables = database.IsUmbracoInstalled();
// database has umbraco tables, assume Umbraco is already installed
if (hasUmbracoTables)
{
return(Task.CompletedTask);
}
// all conditions fulfilled, do the install
_logger.LogInformation("Starting unattended install.");
database.BeginTransaction();
DatabaseSchemaCreator creator = _databaseSchemaCreatorFactory.Create(database);
creator.InitializeDatabaseSchema();
database.CompleteTransaction();
_logger.LogInformation("Unattended install completed.");
// Emit an event with EventAggregator that unattended install completed
// Then this event can be listened for and create an unattended user
_eventAggregator.Publish(new UnattendedInstallNotification());
}
}
catch (Exception ex)
{
_logger.LogInformation(ex, "Error during unattended install.");
database?.AbortTransaction();
var innerException = new UnattendedInstallException(
"The database configuration failed."
+ "\n Please check log file for additional information (can be found in '/Umbraco/Data/Logs/')",
ex);
_runtimeState.Configure(Core.RuntimeLevel.BootFailed, Core.RuntimeLevelReason.BootFailedOnException, innerException);
}
return(Task.CompletedTask);
}
public void CreateDatabase() // FIXME: move to DatabaseBuilderTest!
{
var path = TestHelper.CurrentAssemblyDirectory;
AppDomain.CurrentDomain.SetData("DataDirectory", path);
// delete database file
// NOTE: using a custom db file for this test since we're re-using the one created with BaseDatabaseFactoryTest
var filePath = string.Concat(path, "\\DatabaseContextTests.sdf");
if (File.Exists(filePath))
{
File.Delete(filePath);
}
// get the connectionstring settings from config
var settings = ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName];
// by default the conn string is: Datasource=|DataDirectory|UmbracoNPocoTests.sdf;Flush Interval=1;
// replace the SDF file with our own and create the sql ce database
var connString = settings.ConnectionString.Replace("UmbracoNPocoTests", "DatabaseContextTests");
using (var engine = new SqlCeEngine(connString))
{
engine.CreateDatabase();
}
// re-create the database factory and database context with proper connection string
_databaseFactory = new UmbracoDatabaseFactory(connString, Constants.DbProviderNames.SqlCe, _logger, new Lazy <IMapperCollection>(() => Mock.Of <IMapperCollection>()));
// test get database type (requires an actual database)
using (var database = _databaseFactory.CreateDatabase())
{
var databaseType = database.DatabaseType;
Assert.AreEqual(DatabaseType.SQLCe, databaseType);
}
// create application context
//var appCtx = new ApplicationContext(
// _databaseFactory,
// new ServiceContext(migrationEntryService: Mock.Of<IMigrationEntryService>()),
// CacheHelper.CreateDisabledCacheHelper(),
// new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>()));
// create the umbraco database
DatabaseSchemaCreator schemaHelper;
using (var database = _databaseFactory.CreateDatabase())
using (var transaction = database.GetTransaction())
{
schemaHelper = new DatabaseSchemaCreator(database, _logger);
schemaHelper.InitializeDatabaseSchema();
transaction.Complete();
}
var umbracoNodeTable = schemaHelper.TableExists("umbracoNode");
var umbracoUserTable = schemaHelper.TableExists("umbracoUser");
var cmsTagsTable = schemaHelper.TableExists("cmsTags");
Assert.That(umbracoNodeTable, Is.True);
Assert.That(umbracoUserTable, Is.True);
Assert.That(cmsTagsTable, Is.True);
}
