Added configuration validation for models builder and hosting settings.

Renamed models builder config class suffix to match others.

src/Umbraco.Core/Configuration/Models/ContentSettings.cs

@@ -19,7 +19,11 @@ namespace Umbraco.Core.Configuration.Models
 
         public string PreviewBadge { get; set; } = DefaultPreviewBadge;
 
-        public string MacroErrors { get; set; } = MacroErrorBehaviour.Inline.ToString();
+        // We could bind the enum MacroErrorsBehaviour directly from configuration, but we're doing so
+        // via this string to allow for validation to occur on start-up that the configured value does
+        // match one of the enum values.
+        // Without this it'll fail on first use, and we'd have less control over the error message.
+        internal string MacroErrors { get; set; } = MacroErrorBehaviour.Inline.ToString();
 
         public MacroErrorBehaviour MacroErrorsBehaviour
         {

src/Umbraco.Core/Configuration/Models/HostingSettings.cs

@@ -1,13 +1,26 @@
-namespace Umbraco.Core.Configuration.Models
+using System;
+
+namespace Umbraco.Core.Configuration.Models
 {
     public class HostingSettings
     {
         public string ApplicationVirtualPath { get; set; }
 
+        // See note on ContentSettings.MacroErrors
+        internal string LocalTempStorageLocation { get; set; } = LocalTempStorage.Default.ToString();
+
         /// <summary>
         /// Gets the configuration for the location of temporary files.
         /// </summary>
-        public LocalTempStorage LocalTempStorageLocation { get; set; } = LocalTempStorage.Default;
+        public LocalTempStorage LocalTempStorageLocationValue
+        {
+            get
+            {
+                return Enum.TryParse<LocalTempStorage>(LocalTempStorageLocation, true, out var value)
+                    ? value
+                    : LocalTempStorage.Default;
+            }
+        }
 
         /// <summary>
         /// Gets a value indicating whether umbraco is running in [debug mode].

src/Umbraco.Core/Configuration/Models/ModelsBuilderSettings.cs

@@ -1,11 +1,12 @@
-using Umbraco.Configuration;
+using System;
+using Umbraco.Configuration;
 
 namespace Umbraco.Core.Configuration.Models
 {
     /// <summary>
     ///     Represents the models builder configuration.
     /// </summary>
-    public class ModelsBuilderConfig 
+    public class ModelsBuilderSettings 
     {
         public static string DefaultModelsDirectory => "~/App_Data/Models";
 
@@ -18,10 +19,21 @@ namespace Umbraco.Core.Configuration.Models
         /// </remarks>
         public bool Enable { get; set; } = false;
 
+        // See note on ContentSettings.MacroErrors
+        internal string ModelsMode { get; set; } = Configuration.ModelsMode.Nothing.ToString();
+
         /// <summary>
         ///     Gets the models mode.
         /// </summary>
-        public ModelsMode ModelsMode { get; set; } = ModelsMode.Nothing;
+        public ModelsMode ModelsModeValue
+        {
+            get
+            {
+                return Enum.TryParse<ModelsMode>(ModelsMode, true, out var value)
+                    ? value
+                    : Configuration.ModelsMode.Nothing;
+            }
+        }
 
         /// <summary>
         ///     Gets the models namespace.
@@ -51,7 +63,7 @@ namespace Umbraco.Core.Configuration.Models
 
             set
             {
-                if (!ModelsMode.IsLive())
+                if (!ModelsModeValue.IsLive())
                 {
                     _flagOutOfDateModels = false;
                 }

src/Umbraco.Core/Configuration/Models/SmtpSettings.cs

@@ -1,9 +1,13 @@
-using System.Net.Mail;
+using System.ComponentModel.DataAnnotations;
+using System.Net.Mail;
+using Umbraco.Core.Configuration.Models.Validation;
 
 namespace Umbraco.Core.Configuration.Models
 {
-    public class SmtpSettings
+    public class SmtpSettings : ValidatableEntryBase
     {
+        [Required]
+        [EmailAddress]
         public string From { get; set; }
 
         public string Host { get; set; }

src/Umbraco.Core/Configuration/Models/Validation/ConfigurationValidationBase.cs

@@ -20,7 +20,7 @@ namespace Umbraco.Core.Configuration.Models.Validation
 
         public bool ValidateStringIsOneOfEnumValues(string configPath, string value, Type enumType, out string message)
         {
-            var validValues = Enum.GetValues(enumType).OfType<object>().Select(x => x.ToString().ToFirstLowerInvariant());
+            var validValues = Enum.GetValues(enumType).OfType<object>().Select(x => x.ToString());
             return ValidateStringIsOneOfValidValues(configPath, value, validValues, out message);
         }
 
@@ -35,5 +35,17 @@ namespace Umbraco.Core.Configuration.Models.Validation
             message = string.Empty;
             return true;
         }
+
+        public bool ValidateOptionalEntry(string configPath, ValidatableEntryBase value, string validationDescription, out string message)
+        {
+            if (value != null && !value.IsValid())
+            {
+                message = $"Configuration entry {configPath} contains one or more invalid values. {validationDescription}.";
+                return false;
+            }
+
+            message = string.Empty;
+            return true;
+        }
     }
 }

src/Umbraco.Core/Configuration/Models/Validation/GlobalSettingsValidation.cs

@@ -0,0 +1,22 @@
+using Microsoft.Extensions.Options;
+
+namespace Umbraco.Core.Configuration.Models.Validation
+{
+    public class GlobalSettingsValidation : ConfigurationValidationBase, IValidateOptions<GlobalSettings>
+    {
+        public ValidateOptionsResult Validate(string name, GlobalSettings options)
+        {
+            if (!ValidateSmtpSetting(options.Smtp, out var message))
+            {
+                return ValidateOptionsResult.Fail(message);
+            }
+
+            return ValidateOptionsResult.Success;
+        }
+
+        private bool ValidateSmtpSetting(SmtpSettings value, out string message)
+        {
+            return ValidateOptionalEntry("Global:Smtp", value, "A valid From email address is required", out message);
+        }
+    }
+}

src/Umbraco.Core/Configuration/Models/Validation/HostingSettingsValidation.cs

@@ -0,0 +1,22 @@
+using Microsoft.Extensions.Options;
+
+namespace Umbraco.Core.Configuration.Models.Validation
+{
+    public class HostingSettingsValidation : ConfigurationValidationBase, IValidateOptions<HostingSettings>
+    {
+        public ValidateOptionsResult Validate(string name, HostingSettings options)
+        {
+            if (!ValidateLocalTempStorageLocation(options.LocalTempStorageLocation, out var message))
+            {
+                return ValidateOptionsResult.Fail(message);
+            }
+
+            return ValidateOptionsResult.Success;
+        }
+
+        private bool ValidateLocalTempStorageLocation(string value, out string message)
+        {
+            return ValidateStringIsOneOfEnumValues("Hosting:LocalTempStorageLocation", value, typeof(LocalTempStorage), out message);
+        }
+    }
+}

src/Umbraco.Core/Configuration/Models/Validation/ModelsBuilderSettingsValidation.cs

@@ -0,0 +1,22 @@
+using Microsoft.Extensions.Options;
+
+namespace Umbraco.Core.Configuration.Models.Validation
+{
+    public class ModelsBuilderSettingsValidation : ConfigurationValidationBase, IValidateOptions<ModelsBuilderSettings>
+    {
+        public ValidateOptionsResult Validate(string name, ModelsBuilderSettings options)
+        {
+            if (!ValidateModelsMode(options.ModelsMode, out var message))
+            {
+                return ValidateOptionsResult.Fail(message);
+            }
+
+            return ValidateOptionsResult.Success;
+        }
+
+        private bool ValidateModelsMode(string value, out string message)
+        {
+            return ValidateStringIsOneOfEnumValues("ModelsBuilder:ModelsMode", value, typeof(ModelsMode), out message);
+        }
+    }
+}

src/Umbraco.Core/Configuration/ModelsBuilderConfigExtensions.cs

@@ -10,7 +10,7 @@ namespace Umbraco.Core.Configuration
     {
         private static string _modelsDirectoryAbsolute = null;
 
-        public static string ModelsDirectoryAbsolute(this ModelsBuilderConfig modelsBuilderConfig, IHostingEnvironment hostingEnvironment)
+        public static string ModelsDirectoryAbsolute(this ModelsBuilderSettings modelsBuilderConfig, IHostingEnvironment hostingEnvironment)
         {
             if (_modelsDirectoryAbsolute is null)
             {

src/Umbraco.Core/Constants-Configuration.cs

@@ -12,8 +12,6 @@
             /// </remarks>
             public const string ConfigPrefix = "Umbraco:CMS:";
             public const string ConfigSecurityPrefix = ConfigPrefix+"Security:";
-            public const string ConfigGlobalPrefix = ConfigPrefix + "Global:";
-            public const string ConfigModelsBuilderPrefix = ConfigPrefix+"ModelsBuilder:";
             public const string ConfigRuntimeMinification = ConfigPrefix+"RuntimeMinification";
             public const string ConfigRuntimeMinificationVersion = ConfigRuntimeMinification+":Version";
         }

src/Umbraco.ModelsBuilder.Embedded/BackOffice/ContentTypeModelValidator.cs

@@ -11,7 +11,7 @@ namespace Umbraco.ModelsBuilder.Embedded.BackOffice
     // ReSharper disable once UnusedMember.Global - This is typed scanned
     public class ContentTypeModelValidator : ContentTypeModelValidatorBase<DocumentTypeSave, PropertyTypeBasic>
     {
-        public ContentTypeModelValidator(IOptions<ModelsBuilderConfig> config) : base(config)
+        public ContentTypeModelValidator(IOptions<ModelsBuilderSettings> config) : base(config)
         {
         }
     }

src/Umbraco.ModelsBuilder.Embedded/BackOffice/ContentTypeModelValidatorBase.cs

@@ -14,9 +14,9 @@ namespace Umbraco.ModelsBuilder.Embedded.BackOffice
         where TModel : ContentTypeSave<TProperty>
         where TProperty : PropertyTypeBasic
     {
-        private readonly IOptions<ModelsBuilderConfig> _config;
+        private readonly IOptions<ModelsBuilderSettings> _config;
 
-        public ContentTypeModelValidatorBase(IOptions<ModelsBuilderConfig> config)
+        public ContentTypeModelValidatorBase(IOptions<ModelsBuilderSettings> config)
         {
             _config = config;
         }

src/Umbraco.ModelsBuilder.Embedded/BackOffice/DashboardReport.cs

@@ -8,18 +8,18 @@ namespace Umbraco.ModelsBuilder.Embedded.BackOffice
 {
     internal class DashboardReport
     {
-        private readonly ModelsBuilderConfig _config;
+        private readonly ModelsBuilderSettings _config;
         private readonly OutOfDateModelsStatus _outOfDateModels;
         private readonly ModelsGenerationError _mbErrors;
 
-        public DashboardReport(IOptions<ModelsBuilderConfig> config, OutOfDateModelsStatus outOfDateModels, ModelsGenerationError mbErrors)
+        public DashboardReport(IOptions<ModelsBuilderSettings> config, OutOfDateModelsStatus outOfDateModels, ModelsGenerationError mbErrors)
         {
             _config = config.Value;
             _outOfDateModels = outOfDateModels;
             _mbErrors = mbErrors;
         }
 
-        public bool CanGenerate() => _config.ModelsMode.SupportsExplicitGeneration();
+        public bool CanGenerate() => _config.ModelsModeValue.SupportsExplicitGeneration();
 
         public bool AreModelsOutOfDate() => _outOfDateModels.IsOutOfDate;
 
@@ -41,13 +41,13 @@ namespace Umbraco.ModelsBuilder.Embedded.BackOffice
             sb.Append("<ul>");
 
             sb.Append("<li>The <strong>models factory</strong> is ");
-            sb.Append(_config.EnableFactory || _config.ModelsMode == ModelsMode.PureLive
+            sb.Append(_config.EnableFactory || _config.ModelsModeValue == ModelsMode.PureLive
                 ? "enabled"
                 : "not enabled. Umbraco will <em>not</em> use models");
             sb.Append(".</li>");
 
-            sb.Append(_config.ModelsMode != ModelsMode.Nothing
-                ? $"<li><strong>{_config.ModelsMode} models</strong> are enabled.</li>"
+            sb.Append(_config.ModelsModeValue != ModelsMode.Nothing
+                ? $"<li><strong>{_config.ModelsModeValue} models</strong> are enabled.</li>"
                 : "<li>No models mode is specified: models will <em>not</em> be generated.</li>");
 
             sb.Append($"<li>Models namespace is {_config.ModelsNamespace}.</li>");

src/Umbraco.ModelsBuilder.Embedded/BackOffice/MediaTypeModelValidator.cs

@@ -11,7 +11,7 @@ namespace Umbraco.ModelsBuilder.Embedded.BackOffice
     // ReSharper disable once UnusedMember.Global - This is typed scanned
     public class MediaTypeModelValidator : ContentTypeModelValidatorBase<MediaTypeSave, PropertyTypeBasic>
     {
-        public MediaTypeModelValidator(IOptions<ModelsBuilderConfig> config) : base(config)
+        public MediaTypeModelValidator(IOptions<ModelsBuilderSettings> config) : base(config)
         {
         }
     }

src/Umbraco.ModelsBuilder.Embedded/BackOffice/MemberTypeModelValidator.cs

@@ -11,7 +11,7 @@ namespace Umbraco.ModelsBuilder.Embedded.BackOffice
     // ReSharper disable once UnusedMember.Global - This is typed scanned
     public class MemberTypeModelValidator : ContentTypeModelValidatorBase<MemberTypeSave, MemberPropertyTypeBasic>
     {
-        public MemberTypeModelValidator(IOptions<ModelsBuilderConfig> config) : base(config)
+        public MemberTypeModelValidator(IOptions<ModelsBuilderSettings> config) : base(config)
         {
         }
     }

src/Umbraco.ModelsBuilder.Embedded/BackOffice/ModelsBuilderDashboardController.cs

@@ -23,14 +23,14 @@ namespace Umbraco.ModelsBuilder.Embedded.BackOffice
     [UmbracoApplicationAuthorize(Core.Constants.Applications.Settings)]
     public class ModelsBuilderDashboardController : UmbracoAuthorizedJsonController
     {
-        private readonly ModelsBuilderConfig _config;
+        private readonly ModelsBuilderSettings _config;
         private readonly ModelsGenerator _modelGenerator;
         private readonly OutOfDateModelsStatus _outOfDateModels;
         private readonly ModelsGenerationError _mbErrors;
         private readonly DashboardReport _dashboardReport;
         private readonly IHostingEnvironment _hostingEnvironment;
 
-        public ModelsBuilderDashboardController(IOptions<ModelsBuilderConfig> config, ModelsGenerator modelsGenerator, OutOfDateModelsStatus outOfDateModels, ModelsGenerationError mbErrors, IHostingEnvironment hostingEnvironment)
+        public ModelsBuilderDashboardController(IOptions<ModelsBuilderSettings> config, ModelsGenerator modelsGenerator, OutOfDateModelsStatus outOfDateModels, ModelsGenerationError mbErrors, IHostingEnvironment hostingEnvironment)
         {
             //_umbracoServices = umbracoServices;
             _config = config.Value;
@@ -51,7 +51,7 @@ namespace Umbraco.ModelsBuilder.Embedded.BackOffice
             {
                 var config = _config;
 
-                if (!config.ModelsMode.SupportsExplicitGeneration())
+                if (!config.ModelsModeValue.SupportsExplicitGeneration())
                 {
                     var result2 = new BuildResult { Success = false, Message = "Models generation is not enabled." };
                     return Ok(result2);

src/Umbraco.ModelsBuilder.Embedded/Building/Builder.cs

@@ -66,7 +66,7 @@ namespace Umbraco.ModelsBuilder.Embedded.Building
         /// </summary>
         /// <param name="typeModels">The list of models to generate.</param>
         /// <param name="modelsNamespace">The models namespace.</param>
-        protected Builder(ModelsBuilderConfig config, IList<TypeModel> typeModels)
+        protected Builder(ModelsBuilderSettings config, IList<TypeModel> typeModels)
         {
             _typeModels = typeModels ?? throw new ArgumentNullException(nameof(typeModels));
 
@@ -83,7 +83,7 @@ namespace Umbraco.ModelsBuilder.Embedded.Building
         protected Builder()
         { }
 
-        protected ModelsBuilderConfig Config { get; }
+        protected ModelsBuilderSettings Config { get; }
 
         /// <summary>
         /// Prepares generation by processing the result of code parsing.
@@ -92,7 +92,7 @@ namespace Umbraco.ModelsBuilder.Embedded.Building
         {
             TypeModel.MapModelTypes(_typeModels, ModelsNamespace);
 
-            var pureLive = Config.ModelsMode == ModelsMode.PureLive;
+            var pureLive = Config.ModelsModeValue == ModelsMode.PureLive;
 
             // for the first two of these two tests,
             //  always throw, even in purelive: cannot happen unless ppl start fidling with attributes to rename

src/Umbraco.ModelsBuilder.Embedded/Building/ModelsGenerator.cs

@@ -11,11 +11,11 @@ namespace Umbraco.ModelsBuilder.Embedded.Building
     public class ModelsGenerator
     {
         private readonly UmbracoServices _umbracoService;
-        private readonly ModelsBuilderConfig _config;
+        private readonly ModelsBuilderSettings _config;
         private readonly OutOfDateModelsStatus _outOfDateModels;
         private readonly IHostingEnvironment _hostingEnvironment;
 
-        public ModelsGenerator(UmbracoServices umbracoService, IOptions<ModelsBuilderConfig> config, OutOfDateModelsStatus outOfDateModels, IHostingEnvironment hostingEnvironment)
+        public ModelsGenerator(UmbracoServices umbracoService, IOptions<ModelsBuilderSettings> config, OutOfDateModelsStatus outOfDateModels, IHostingEnvironment hostingEnvironment)
         {
             _umbracoService = umbracoService;
             _config = config.Value;

src/Umbraco.ModelsBuilder.Embedded/Building/TextBuilder.cs

@@ -18,7 +18,7 @@ namespace Umbraco.ModelsBuilder.Embedded.Building
         /// and the result of code parsing.
         /// </summary>
         /// <param name="typeModels">The list of models to generate.</param>
-        public TextBuilder(ModelsBuilderConfig config, IList<TypeModel> typeModels)
+        public TextBuilder(ModelsBuilderSettings config, IList<TypeModel> typeModels)
             : base(config, typeModels)
         { }
 

src/Umbraco.ModelsBuilder.Embedded/Compose/ModelsBuilderComponent.cs

@@ -21,7 +21,7 @@ namespace Umbraco.ModelsBuilder.Embedded.Compose
 {
     internal class ModelsBuilderComponent : IComponent
     {
-        private readonly ModelsBuilderConfig _config;
+        private readonly ModelsBuilderSettings _config;
         private readonly IShortStringHelper _shortStringHelper;
         private readonly LiveModelsProvider _liveModelsProvider;
         private readonly OutOfDateModelsStatus _outOfDateModels;
@@ -29,7 +29,7 @@ namespace Umbraco.ModelsBuilder.Embedded.Compose
         private readonly IUmbracoApplicationLifetime _umbracoApplicationLifetime;
         private readonly IUmbracoRequestLifetime _umbracoRequestLifetime;
 
-        public ModelsBuilderComponent(IOptions<ModelsBuilderConfig> config, IShortStringHelper shortStringHelper,
+        public ModelsBuilderComponent(IOptions<ModelsBuilderSettings> config, IShortStringHelper shortStringHelper,
             LiveModelsProvider liveModelsProvider, OutOfDateModelsStatus outOfDateModels, LinkGenerator linkGenerator,
             IUmbracoRequestLifetime umbracoRequestLifetime, IUmbracoApplicationLifetime umbracoApplicationLifetime)
         {
@@ -55,7 +55,7 @@ namespace Umbraco.ModelsBuilder.Embedded.Compose
             if (_config.Enable)
                 FileService.SavingTemplate += FileService_SavingTemplate;
 
-            if (_config.ModelsMode.IsLiveNotPure())
+            if (_config.ModelsModeValue.IsLiveNotPure())
                 _liveModelsProvider.Install();
 
             if (_config.FlagOutOfDateModels)

src/Umbraco.ModelsBuilder.Embedded/Compose/ModelsBuilderComposer.cs

@@ -27,8 +27,8 @@ namespace Umbraco.ModelsBuilder.Embedded.Compose
 
             composition.RegisterUnique<IPublishedModelFactory>(factory =>
             {
-                var config = factory.GetInstance<IOptions<ModelsBuilderConfig>>().Value;
-                if (config.ModelsMode == ModelsMode.PureLive)
+                var config = factory.GetInstance<IOptions<ModelsBuilderSettings>>().Value;
+                if (config.ModelsModeValue == ModelsMode.PureLive)
                 {
                     composition.RegisterUnique<IPublishedModelFactory, PureLiveModelFactory>();
 

src/Umbraco.ModelsBuilder.Embedded/LiveModelsProvider.cs

@@ -20,15 +20,15 @@ namespace Umbraco.ModelsBuilder.Embedded
         private static Mutex _mutex;
         private static int _req;
         private readonly ILogger _logger;
-        private readonly ModelsBuilderConfig _config;
+        private readonly ModelsBuilderSettings _config;
         private readonly ModelsGenerator _modelGenerator;
         private readonly ModelsGenerationError _mbErrors;
         private readonly IHostingEnvironment _hostingEnvironment;
 
         // we do not manage pure live here
-        internal bool IsEnabled => _config.ModelsMode.IsLiveNotPure();
+        internal bool IsEnabled => _config.ModelsModeValue.IsLiveNotPure();
 
-        public LiveModelsProvider(ILogger logger, IOptions<ModelsBuilderConfig> config, ModelsGenerator modelGenerator, ModelsGenerationError mbErrors, IHostingEnvironment hostingEnvironment)
+        public LiveModelsProvider(ILogger logger, IOptions<ModelsBuilderSettings> config, ModelsGenerator modelGenerator, ModelsGenerationError mbErrors, IHostingEnvironment hostingEnvironment)
         {
             _logger = logger;
             _config = config.Value ?? throw new ArgumentNullException(nameof(config));

src/Umbraco.ModelsBuilder.Embedded/ModelsGenerationError.cs

@@ -10,10 +10,10 @@ namespace Umbraco.ModelsBuilder.Embedded
 {
     public sealed class ModelsGenerationError
     {
-        private readonly ModelsBuilderConfig _config;
+        private readonly ModelsBuilderSettings _config;
         private readonly IHostingEnvironment _hostingEnvironment;
 
-        public ModelsGenerationError(IOptions<ModelsBuilderConfig> config, IHostingEnvironment hostingEnvironment)
+        public ModelsGenerationError(IOptions<ModelsBuilderSettings> config, IHostingEnvironment hostingEnvironment)
         {
             _config = config.Value;
             _hostingEnvironment = hostingEnvironment;

src/Umbraco.ModelsBuilder.Embedded/OutOfDateModelsStatus.cs

@@ -9,10 +9,10 @@ namespace Umbraco.ModelsBuilder.Embedded
 {
     public sealed class OutOfDateModelsStatus
     {
-        private readonly ModelsBuilderConfig _config;
+        private readonly ModelsBuilderSettings _config;
         private readonly IHostingEnvironment _hostingEnvironment;
 
-        public OutOfDateModelsStatus(IOptions<ModelsBuilderConfig> config, IHostingEnvironment hostingEnvironment)
+        public OutOfDateModelsStatus(IOptions<ModelsBuilderSettings> config, IHostingEnvironment hostingEnvironment)
         {
             _config = config.Value;
             _hostingEnvironment = hostingEnvironment;

src/Umbraco.ModelsBuilder.Embedded/PureLiveModelFactory.cs

@@ -38,7 +38,7 @@ namespace Umbraco.ModelsBuilder.Embedded
         private static readonly Regex AssemblyVersionRegex = new Regex("AssemblyVersion\\(\"[0-9]+.[0-9]+.[0-9]+.[0-9]+\"\\)", RegexOptions.Compiled);
         private static readonly string[] OurFiles = { "models.hash", "models.generated.cs", "all.generated.cs", "all.dll.path", "models.err", "Compiled" };
 
-        private readonly ModelsBuilderConfig _config;
+        private readonly ModelsBuilderSettings _config;
         private readonly IHostingEnvironment _hostingEnvironment;
         private readonly IApplicationShutdownRegistry _hostingLifetime;
         private readonly ModelsGenerationError _errors;
@@ -47,7 +47,7 @@ namespace Umbraco.ModelsBuilder.Embedded
         public PureLiveModelFactory(
             Lazy<UmbracoServices> umbracoServices,
             IProfilingLogger logger,
-            IOptions<ModelsBuilderConfig> config,
+            IOptions<ModelsBuilderSettings> config,
             IHostingEnvironment hostingEnvironment,
             IApplicationShutdownRegistry hostingLifetime,
             IPublishedValueFallback publishedValueFallback)

src/Umbraco.Tests.Common/Builders/HostingSettingsBuilder.cs

@@ -7,7 +7,7 @@ namespace Umbraco.Tests.Common.Builders
     {
         private string _applicationVirtualPath;
         private bool? _debug;
-        private LocalTempStorage? _localTempStorageLocation;
+        private string _localTempStorageLocation;
 
         public HostingSettingsBuilder WithApplicationVirtualPath(string applicationVirtualPath)
         {
@@ -23,14 +23,14 @@ namespace Umbraco.Tests.Common.Builders
 
         public HostingSettingsBuilder WithLocalTempStorageLocation(LocalTempStorage localTempStorageLocation)
         {
-            _localTempStorageLocation = localTempStorageLocation;
+            _localTempStorageLocation = localTempStorageLocation.ToString();
             return this;
         }
 
         public override HostingSettings Build()
         {
             var debug = _debug ?? false;
-            var localTempStorageLocation = _localTempStorageLocation ?? LocalTempStorage.Default;
+            var localTempStorageLocation = _localTempStorageLocation ?? LocalTempStorage.Default.ToString();
             var applicationVirtualPath = _applicationVirtualPath ?? null;
 
             return new HostingSettings

src/Umbraco.Tests.Common/Builders/ModelsBuilderConfigBuilder.cs

@@ -2,11 +2,11 @@ using Umbraco.Core.Configuration.Models;
 
 namespace Umbraco.Tests.Common.Builders
 {
-    public class ModelsBuilderConfigBuilder : BuilderBase<ModelsBuilderConfig>
+    public class ModelsBuilderConfigBuilder : BuilderBase<ModelsBuilderSettings>
     {
-        public override ModelsBuilderConfig Build()
+        public override ModelsBuilderSettings Build()
         {
-            return new ModelsBuilderConfig();
+            return new ModelsBuilderSettings();
         }
     }
 }

src/Umbraco.Web.Common/AspNetCore/AspNetCoreHostingEnvironment.cs

@@ -45,7 +45,7 @@ namespace Umbraco.Web.Common.AspNetCore
                 if (_localTempPath != null)
                     return _localTempPath;
 
-                switch (_hostingSettings.CurrentValue.LocalTempStorageLocation)
+                switch (_hostingSettings.CurrentValue.LocalTempStorageLocationValue)
                 {
                     case LocalTempStorage.AspNetTemp:
 

src/Umbraco.Web.Common/Extensions/UmbracoCoreServiceCollectionExtensions.cs

@@ -128,22 +128,25 @@ namespace Umbraco.Extensions
             if (configuration == null) throw new ArgumentNullException(nameof(configuration));
 
             services.AddSingleton<IValidateOptions<ContentSettings>, ContentSettingsValidation>();
+            services.AddSingleton<IValidateOptions<GlobalSettings>, GlobalSettingsValidation>();
+            services.AddSingleton<IValidateOptions<HostingSettings>, HostingSettingsValidation>();
+            services.AddSingleton<IValidateOptions<ModelsBuilderSettings>, ModelsBuilderSettingsValidation>();
             services.AddSingleton<IValidateOptions<RequestHandlerSettings>, RequestHandlerSettingsValidation>();
 
             services.Configure<ActiveDirectorySettings>(configuration.GetSection(Constants.Configuration.ConfigPrefix + "ActiveDirectory"));
             services.Configure<ConnectionStrings>(configuration.GetSection("ConnectionStrings"), o => o.BindNonPublicProperties = true);
-            services.Configure<ContentSettings>(configuration.GetSection(Constants.Configuration.ConfigPrefix + "Content"));
+            services.Configure<ContentSettings>(configuration.GetSection(Constants.Configuration.ConfigPrefix + "Content"), o => o.BindNonPublicProperties = true);
             services.Configure<CoreDebugSettings>(configuration.GetSection(Constants.Configuration.ConfigPrefix + "Core:Debug"));
             services.Configure<ExceptionFilterSettings>(configuration.GetSection(Constants.Configuration.ConfigPrefix + "ExceptionFilter"));
             services.Configure<GlobalSettings>(configuration.GetSection(Constants.Configuration.ConfigPrefix + "Global"));
             services.Configure<HealthChecksSettings>(configuration.GetSection(Constants.Configuration.ConfigPrefix + "HealthChecks"));
-            services.Configure<HostingSettings>(configuration.GetSection(Constants.Configuration.ConfigPrefix + "Hosting"));
+            services.Configure<HostingSettings>(configuration.GetSection(Constants.Configuration.ConfigPrefix + "Hosting"), o => o.BindNonPublicProperties = true);
             services.Configure<ImagingSettings>(configuration.GetSection(Constants.Configuration.ConfigPrefix + "Imaging"));
             services.Configure<IndexCreatorSettings>(configuration.GetSection(Constants.Configuration.ConfigPrefix + "Examine"));
             services.Configure<KeepAliveSettings>(configuration.GetSection(Constants.Configuration.ConfigPrefix + "KeepAlive"));
             services.Configure<LoggingSettings>(configuration.GetSection(Constants.Configuration.ConfigPrefix + "Logging"));
             services.Configure<MemberPasswordConfigurationSettings>(configuration.GetSection(Constants.Configuration.ConfigSecurityPrefix + "MemberPassword"));
-            services.Configure<ModelsBuilderConfig>(configuration.GetSection(Constants.Configuration.ConfigGlobalPrefix + "ModelsBuilder"));
+            services.Configure<ModelsBuilderSettings>(configuration.GetSection(Constants.Configuration.ConfigPrefix + "ModelsBuilder"), o => o.BindNonPublicProperties = true);
             services.Configure<NuCacheSettings>(configuration.GetSection(Constants.Configuration.ConfigPrefix + "NuCache"));
             services.Configure<RequestHandlerSettings>(configuration.GetSection(Constants.Configuration.ConfigPrefix + "RequestHandler"));
             services.Configure<RuntimeSettings>(configuration.GetSection(Constants.Configuration.ConfigPrefix + "Runtime"));

src/Umbraco.Web/AspNet/AspNetHostingEnvironment.cs

@@ -63,7 +63,7 @@ namespace Umbraco.Web.Hosting
                 if (_localTempPath != null)
                     return _localTempPath;
 
-                switch (_hostingSettings.LocalTempStorageLocation)
+                switch (_hostingSettings.LocalTempStorageLocationValue)
                 {
                     case LocalTempStorage.AspNetTemp:
                         return _localTempPath = System.IO.Path.Combine(HttpRuntime.CodegenDir, "UmbracoData");

src/Umbraco.Web/WebAssets/CDF/ClientDependencyComponent.cs

@@ -46,7 +46,7 @@ namespace Umbraco.Web.WebAssets.CDF
 
             // Now we need to detect if we are running 'Umbraco.Core.LocalTempStorage' as EnvironmentTemp and in that case we want to change the CDF file
             // location to be there
-            if (_hostingSettings.LocalTempStorageLocation == LocalTempStorage.EnvironmentTemp)
+            if (_hostingSettings.LocalTempStorageLocationValue == LocalTempStorage.EnvironmentTemp)
             {
                 var cachePath = _hostingEnvironment.LocalTempPath;