Merge remote-tracking branch 'origin/temp8' into temp8-logviewer

# Conflicts:
#	src/Umbraco.Core/Migrations/Install/DatabaseSchemaCreator.cs

src/Umbraco.Tests/App.config

@@ -67,7 +67,7 @@
   </appSettings>
 
   <connectionStrings>
-    <add name="umbracoDbDSN" connectionString="Datasource=|DataDirectory|UmbracoNPocoTests.sdf;Flush Interval=1;" providerName="System.Data.SqlServerCe.4.0"/>
+      <add name="umbracoDbDSN" connectionString="Datasource=|DataDirectory|UmbracoNPocoTests.sdf;Flush Interval=1;" providerName="System.Data.SqlServerCe.4.0"/>
   </connectionStrings>
 
   <system.data>

src/Umbraco.Tests/Cache/DistributedCache/DistributedCacheTests.cs

@@ -1,11 +1,15 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using LightInject;
+using Moq;
 using NUnit.Framework;
+using Umbraco.Core;
 using Umbraco.Core.Cache;
+using Umbraco.Core.Components;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Logging;
 using Umbraco.Core.Sync;
+using Umbraco.Tests.Components;
 
 namespace Umbraco.Tests.Cache.DistributedCache
 {
@@ -20,15 +24,18 @@ namespace Umbraco.Tests.Cache.DistributedCache
         [SetUp]
         public void Setup()
         {
-            var container = new ServiceContainer();
-            container.ConfigureUmbracoCore();
+            var register = RegisterFactory.Create();
 
-            container.Register<IServerRegistrar>(_ => new TestServerRegistrar());
-            container.Register<IServerMessenger>(_ => new TestServerMessenger(), new PerContainerLifetime());
+            var composition = new Composition(register, new TypeLoader(), Mock.Of<IProfilingLogger>(), ComponentTests.MockRuntimeState(RuntimeLevel.Run));
 
-            container.RegisterCollectionBuilder<CacheRefresherCollectionBuilder>()
+            composition.RegisterUnique<IServerRegistrar>(_ => new TestServerRegistrar());
+            composition.RegisterUnique<IServerMessenger>(_ => new TestServerMessenger());
+
+            composition.WithCollectionBuilder<CacheRefresherCollectionBuilder>()
                 .Add<TestCacheRefresher>();
 
+            Current.Factory = composition.CreateFactory();
+
             _distributedCache = new Umbraco.Web.Cache.DistributedCache();
         }
 

src/Umbraco.Tests/Cache/DistributedCacheBinderTests.cs

@@ -3,6 +3,7 @@ using System.Linq;
 using System.Threading;
 using Moq;
 using NUnit.Framework;
+using Umbraco.Core.Components;
 using Umbraco.Core.Composing;
 using Umbraco.Core.Events;
 using Umbraco.Core.Models;
@@ -19,6 +20,15 @@ namespace Umbraco.Tests.Cache
     [UmbracoTest(WithApplication = true)]
     public class DistributedCacheBinderTests : UmbracoTestBase
     {
+        protected override void Compose(Composition composition)
+        {
+            base.Compose(composition);
+            // refreshers.HandleEvents wants a UmbracoContext
+            // which wants these
+            composition.RegisterUnique(_ => Mock.Of<IPublishedSnapshotService>());
+            composition.WithCollectionBuilder<UrlProviderCollectionBuilder>();
+        }
+
         [Test]
         public void Can_Find_All_Event_Handlers()
         {
@@ -138,11 +148,6 @@ namespace Umbraco.Tests.Cache
             if (domain.GetData(".appVPath") == null)
                 domain.SetData(".appVPath", "");
 
-            // refreshers.HandleEvents wants a UmbracoContext
-            // which wants these
-            Container.RegisterSingleton(_ => Mock.Of<IPublishedSnapshotService>());
-            Container.RegisterCollectionBuilder<UrlProviderCollectionBuilder>();
-
             // create some event definitions
             var definitions = new IEventDefinition[]
             {

src/Umbraco.Tests/Cache/PublishedCache/PublishedMediaCacheTests.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Xml;
@@ -7,13 +6,13 @@ using Examine;
 using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Core.Cache;
+using Umbraco.Core.Composing;
 using Umbraco.Core.Models.PublishedContent;
 using Umbraco.Core.Strings;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Web.PublishedCache.XmlPublishedCache;
 using Umbraco.Tests.Testing;
 using Current = Umbraco.Web.Composing.Current;
-using LightInject;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Membership;
 using Umbraco.Tests.PublishedContent;
@@ -30,7 +29,7 @@ namespace Umbraco.Tests.Cache.PublishedCache
         {
             base.Compose();
 
-            Container.GetInstance<UrlSegmentProviderCollectionBuilder>()
+            Composition.WithCollectionBuilder<UrlSegmentProviderCollectionBuilder>()
                 .Clear()
                 .Append<DefaultUrlSegmentProvider>();
         }

src/Umbraco.Tests/Clr/ReflectionUtilitiesTests.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Reflection;
 using NUnit.Framework;
 using Umbraco.Core;
@@ -13,16 +14,16 @@ namespace Umbraco.Tests.Clr
         [Test]
         public void EmitCtorEmits()
         {
-            var ctor1 = ReflectionUtilities.EmitConstuctor<Func<Class1>>();
+            var ctor1 = ReflectionUtilities.EmitConstructor<Func<Class1>>();
             Assert.IsInstanceOf<Class1>(ctor1());
 
-            var ctor2 = ReflectionUtilities.EmitConstuctor<Func<object>>(declaring: typeof(Class1));
+            var ctor2 = ReflectionUtilities.EmitConstructor<Func<object>>(declaring: typeof(Class1));
             Assert.IsInstanceOf<Class1>(ctor2());
 
-            var ctor3 = ReflectionUtilities.EmitConstuctor<Func<int, Class3>>();
+            var ctor3 = ReflectionUtilities.EmitConstructor<Func<int, Class3>>();
             Assert.IsInstanceOf<Class3>(ctor3(42));
 
-            var ctor4 = ReflectionUtilities.EmitConstuctor<Func<int, object>>(declaring: typeof(Class3));
+            var ctor4 = ReflectionUtilities.EmitConstructor<Func<int, object>>(declaring: typeof(Class3));
             Assert.IsInstanceOf<Class3>(ctor4(42));
         }
 
@@ -43,14 +44,14 @@ namespace Umbraco.Tests.Clr
         [Test]
         public void EmitCtorEmitsPrivateCtor()
         {
-            var ctor = ReflectionUtilities.EmitConstuctor<Func<string, Class3>>();
+            var ctor = ReflectionUtilities.EmitConstructor<Func<string, Class3>>();
             Assert.IsInstanceOf<Class3>(ctor("foo"));
         }
 
         [Test]
         public void EmitCtorThrowsIfNotFound()
         {
-            Assert.Throws<InvalidOperationException>(() => ReflectionUtilities.EmitConstuctor<Func<bool, Class3>>());
+            Assert.Throws<InvalidOperationException>(() => ReflectionUtilities.EmitConstructor<Func<bool, Class3>>());
         }
 
         [Test]
@@ -63,7 +64,7 @@ namespace Umbraco.Tests.Clr
         [Test]
         public void EmitCtorReturnsNull()
         {
-            Assert.IsNull(ReflectionUtilities.EmitConstuctor<Func<bool, Class3>>(false));
+            Assert.IsNull(ReflectionUtilities.EmitConstructor<Func<bool, Class3>>(false));
         }
 
         [Test]
@@ -553,6 +554,22 @@ namespace Umbraco.Tests.Clr
 
         // fixme - missing tests specifying 'returned' on method, property
 
+        [Test]
+        public void DeconstructAnonymousType()
+        {
+            var o = new { a = 1, b = "hello" };
+
+            var getters = new Dictionary<string, Func<object, object>>();
+            foreach (var prop in o.GetType().GetProperties())
+                getters[prop.Name] = ReflectionUtilities.EmitMethodUnsafe<Func<object, object>>(prop.GetMethod);
+
+            Assert.AreEqual(2, getters.Count);
+            Assert.IsTrue(getters.ContainsKey("a"));
+            Assert.IsTrue(getters.ContainsKey("b"));
+            Assert.AreEqual(1, getters["a"](o));
+            Assert.AreEqual("hello", getters["b"](o));
+        }
+
         #region IL Code
 
         // these functions can be examined in eg DotPeek to understand IL works

src/Umbraco.Tests/Components/ComponentTests.cs

@@ -1,17 +1,16 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using LightInject;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Core.Components;
+using Umbraco.Core.Composing;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.Mappers;
 using Umbraco.Core.Scoping;
-using Umbraco.Tests.TestHelpers;
 
 namespace Umbraco.Tests.Components
 {
@@ -21,132 +20,176 @@ namespace Umbraco.Tests.Components
         private static readonly List<Type> Composed = new List<Type>();
         private static readonly List<string> Initialized = new List<string>();
 
-        private static IServiceContainer MockContainer(Action<Mock<IServiceContainer>> setup = null)
+        private static IFactory MockFactory(Action<Mock<IFactory>> setup = null)
         {
             // fixme use IUmbracoDatabaseFactory vs UmbracoDatabaseFactory, clean it all up!
 
-            var testObjects = new TestObjects(null);
+            var mock = new Mock<IFactory>();
+
             var logger = Mock.Of<ILogger>();
-            var s = testObjects.GetDefaultSqlSyntaxProviders(logger);
-            var f = new UmbracoDatabaseFactory(s, logger, new MapperCollection(Enumerable.Empty<BaseMapper>()));
-            var fs = new FileSystems(logger);
+            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);
 
-            var mock = new Mock<IServiceContainer>();
             mock.Setup(x => x.GetInstance(typeof (ILogger))).Returns(logger);
-            mock.Setup(x => x.GetInstance(typeof (ProfilingLogger))).Returns(new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>()));
+            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 IRegister MockRegister()
+        {
+            return Mock.Of<IRegister>();
+        }
+
+        private static TypeLoader MockTypeLoader()
+        {
+            return new TypeLoader();
+        }
+
+        public static IRuntimeState MockRuntimeState(RuntimeLevel level)
+        {
+            var runtimeState = Mock.Of<IRuntimeState>();
+            Mock.Get(runtimeState).Setup(x => x.Level).Returns(level);
+            return runtimeState;
+        }
+
         [Test]
         public void Boot1A()
         {
-            var container = MockContainer();
+            var register = MockRegister();
+            var composition = new Composition(register, MockTypeLoader(), Mock.Of<IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
 
-            var loader = new BootLoader(container);
+            var types = TypeArray<Composer1, Composer2, Composer3, Composer4>();
+            var components = new Core.Components.Composers(composition, types, Mock.Of<IProfilingLogger>());
             Composed.Clear();
             // 2 is Core and requires 4
             // 3 is User - goes away with RuntimeLevel.Unknown
             // => reorder components accordingly
-            loader.Boot(TypeArray<Component1, Component2, Component3, Component4>(), RuntimeLevel.Unknown);
-            AssertTypeArray(TypeArray<Component1, Component4, Component2>(), Composed);
+            components.Compose();
+            AssertTypeArray(TypeArray<Composer1, Composer4, Composer2>(), Composed);
         }
 
         [Test]
         public void Boot1B()
         {
-            var container = MockContainer();
+            var register = MockRegister();
+            var composition = new Composition(register, MockTypeLoader(), Mock.Of<IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Run));
 
-            var loader = new BootLoader(container);
+            var types = TypeArray<Composer1, Composer2, Composer3, Composer4>();
+            var components = new Core.Components.Composers(composition, types, Mock.Of<IProfilingLogger>());
             Composed.Clear();
             // 2 is Core and requires 4
             // 3 is User - stays with RuntimeLevel.Run
             // => reorder components accordingly
-            loader.Boot(TypeArray<Component1, Component2, Component3, Component4>(), RuntimeLevel.Run);
-            AssertTypeArray(TypeArray<Component1, Component4, Component2, Component3>(), Composed);
+            components.Compose();
+            AssertTypeArray(TypeArray<Composer1, Composer4, Composer2, Composer3>(), Composed);
         }
 
         [Test]
         public void Boot2()
         {
-            var container = MockContainer();
+            var register = MockRegister();
+            var composition = new Composition(register, MockTypeLoader(), Mock.Of<IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
 
-            var loader = new BootLoader(container);
+            var types = TypeArray<Composer20, Composer21>();
+            var components = new Core.Components.Composers(composition, types, Mock.Of<IProfilingLogger>());
             Composed.Clear();
             // 21 is required by 20
             // => reorder components accordingly
-            loader.Boot(TypeArray<Component20, Component21>(), RuntimeLevel.Unknown);
-            AssertTypeArray(TypeArray<Component21, Component20>(), Composed);
+            components.Compose();
+            AssertTypeArray(TypeArray<Composer21, Composer20>(), Composed);
         }
 
         [Test]
         public void Boot3()
         {
-            var container = MockContainer();
+            var register = MockRegister();
+            var composition = new Composition(register, MockTypeLoader(), Mock.Of<IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
 
-            var loader = new BootLoader(container);
+            var types = TypeArray<Composer22, Composer24, Composer25>();
+            var components = new Core.Components.Composers(composition, types, Mock.Of<IProfilingLogger>());
             Composed.Clear();
             // i23 requires 22
             // 24, 25 implement i23
             // 25 required by i23
             // => reorder components accordingly
-            loader.Boot(TypeArray<Component22, Component24, Component25>(), RuntimeLevel.Unknown);
-            AssertTypeArray(TypeArray<Component22, Component25, Component24>(), Composed);
+            components.Compose();
+            AssertTypeArray(TypeArray<Composer22, Composer25, Composer24>(), Composed);
         }
 
         [Test]
         public void BrokenRequire()
         {
-            var container = MockContainer();
+            var register = MockRegister();
+            var composition = new Composition(register, MockTypeLoader(), Mock.Of<IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
 
-            var thing = new BootLoader(container);
+            var types = TypeArray<Composer1, Composer2, Composer3>();
+            var components = new Core.Components.Composers(composition, types, Mock.Of<IProfilingLogger>());
             Composed.Clear();
             try
             {
                 // 2 is Core and requires 4
                 // 4 is missing
                 // => throw
-                thing.Boot(TypeArray < Component1, Component2, Component3>(), RuntimeLevel.Unknown);
+                components.Compose();
                 Assert.Fail("Expected exception.");
             }
             catch (Exception e)
             {
-                Assert.AreEqual("Broken component dependency: Umbraco.Tests.Components.ComponentTests+Component2 -> Umbraco.Tests.Components.ComponentTests+Component4.", e.Message);
+                Assert.AreEqual("Broken composer dependency: Umbraco.Tests.Components.ComponentTests+Composer2 -> Umbraco.Tests.Components.ComponentTests+Composer4.", e.Message);
             }
         }
 
         [Test]
         public void BrokenRequired()
         {
-            var container = MockContainer();
+            var register = MockRegister();
+            var composition = new Composition(register, MockTypeLoader(), Mock.Of<IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
 
-            var thing = new BootLoader(container);
+            var types = TypeArray<Composer2, Composer4, Composer13>();
+            var components = new Core.Components.Composers(composition, types, Mock.Of<IProfilingLogger>());
             Composed.Clear();
             // 2 is Core and requires 4
             // 13 is required by 1
             // 1 is missing
             // => reorder components accordingly
-            thing.Boot(TypeArray<Component2, Component4, Component13>(), RuntimeLevel.Unknown);
-            AssertTypeArray(TypeArray<Component4, Component2, Component13>(), Composed);
+            components.Compose();
+            AssertTypeArray(TypeArray<Composer4, Composer2, Composer13>(), Composed);
         }
 
         [Test]
         public void Initialize()
         {
-            var container = MockContainer(m =>
+            var register = MockRegister();
+            var factory = MockFactory(m =>
             {
                 m.Setup(x => x.TryGetInstance(It.Is<Type>(t => t == typeof (ISomeResource)))).Returns(() => new SomeResource());
+                m.Setup(x => x.GetInstance(It.IsAny<Type>())).Returns<Type>((type) =>
+                {
+                    if (type == typeof(Composer1)) return new Composer1();
+                    if (type == typeof(Composer5)) return new Composer5();
+                    if (type == typeof(Component5)) return new Component5(new SomeResource());
+                    if (type == typeof(IProfilingLogger)) return new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>());
+                    throw new NotSupportedException(type.FullName);
+                });
             });
+            var composition = new Composition(register, MockTypeLoader(), Mock.Of<IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
 
-            var thing = new BootLoader(container);
+            var types = new[] { typeof(Composer1), typeof(Composer5) };
+            var composers = new Composers(composition, types, Mock.Of<IProfilingLogger>());
             Composed.Clear();
-            thing.Boot(new[] { typeof(Component1), typeof(Component5) }, RuntimeLevel.Unknown);
+            Initialized.Clear();
+            composers.Compose();
+            var builder = composition.WithCollectionBuilder<ComponentCollectionBuilder>();
+            builder.RegisterWith(register);
+            var components = builder.CreateCollection(factory);
             Assert.AreEqual(2, Composed.Count);
-            Assert.AreEqual(typeof(Component1), Composed[0]);
-            Assert.AreEqual(typeof(Component5), Composed[1]);
+            Assert.AreEqual(typeof(Composer1), Composed[0]);
+            Assert.AreEqual(typeof(Composer5), Composed[1]);
             Assert.AreEqual(1, Initialized.Count);
             Assert.AreEqual("Umbraco.Tests.Components.ComponentTests+SomeResource", Initialized[0]);
         }
@@ -154,174 +197,202 @@ namespace Umbraco.Tests.Components
         [Test]
         public void Requires1()
         {
-            var container = MockContainer();
+            var register = MockRegister();
+            var composition = new Composition(register, MockTypeLoader(), Mock.Of<IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
 
-            var thing = new BootLoader(container);
+            var types = new[] { typeof(Composer6), typeof(Composer7), typeof(Composer8) };
+            var components = new Core.Components.Composers(composition, types, Mock.Of<IProfilingLogger>());
             Composed.Clear();
-            thing.Boot(new[] { typeof(Component6), typeof(Component7), typeof(Component8) }, RuntimeLevel.Unknown);
+            components.Compose();
             Assert.AreEqual(2, Composed.Count);
-            Assert.AreEqual(typeof(Component6), Composed[0]);
-            Assert.AreEqual(typeof(Component8), Composed[1]);
+            Assert.AreEqual(typeof(Composer6), Composed[0]);
+            Assert.AreEqual(typeof(Composer8), Composed[1]);
         }
 
         [Test]
         public void Requires2A()
         {
-            var container = MockContainer();
+            var register = MockRegister();
+            var composition = new Composition(register, MockTypeLoader(), Mock.Of<IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
 
-            var thing = new BootLoader(container);
+            var types = new[] { typeof(Composer9), typeof(Composer2), typeof(Composer4) };
+            var components = new Core.Components.Composers(composition, types, Mock.Of<IProfilingLogger>());
             Composed.Clear();
-            thing.Boot(new[] { typeof(Component9), typeof(Component2), typeof(Component4) }, RuntimeLevel.Unknown);
+            components.Compose();
             Assert.AreEqual(2, Composed.Count);
-            Assert.AreEqual(typeof(Component4), Composed[0]);
-            Assert.AreEqual(typeof(Component2), Composed[1]);
+            Assert.AreEqual(typeof(Composer4), Composed[0]);
+            Assert.AreEqual(typeof(Composer2), Composed[1]);
             //Assert.AreEqual(typeof(Component9), Composed[2]); -- goes away with RuntimeLevel.Unknown
         }
 
         [Test]
         public void Requires2B()
         {
-            var container = MockContainer();
+            var register = MockRegister();
+            var factory = MockFactory();
+            var composition = new Composition(register, MockTypeLoader(), Mock.Of<IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Run));
 
-            var thing = new BootLoader(container);
+            var types = new[] { typeof(Composer9), typeof(Composer2), typeof(Composer4) };
+            var composers = new Composers(composition, types, Mock.Of<IProfilingLogger>());
             Composed.Clear();
-            thing.Boot(new[] { typeof(Component9), typeof(Component2), typeof(Component4) }, RuntimeLevel.Run);
+            composers.Compose();
+            var builder = composition.WithCollectionBuilder<ComponentCollectionBuilder>();
+            builder.RegisterWith(register);
+            var components = builder.CreateCollection(factory);
             Assert.AreEqual(3, Composed.Count);
-            Assert.AreEqual(typeof(Component4), Composed[0]);
-            Assert.AreEqual(typeof(Component2), Composed[1]);
-            Assert.AreEqual(typeof(Component9), Composed[2]);
+            Assert.AreEqual(typeof(Composer4), Composed[0]);
+            Assert.AreEqual(typeof(Composer2), Composed[1]);
+            Assert.AreEqual(typeof(Composer9), Composed[2]);
         }
 
         [Test]
         public void WeakDependencies()
         {
-            var container = MockContainer();
+            var register = MockRegister();
+            var composition = new Composition(register, MockTypeLoader(), Mock.Of<IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
 
-            var thing = new BootLoader(container);
+            var types = new[] { typeof(Composer10) };
+            var components = new Core.Components.Composers(composition, types, Mock.Of<IProfilingLogger>());
             Composed.Clear();
-            thing.Boot(new[] { typeof(Component10) }, RuntimeLevel.Unknown);
+            components.Compose();
             Assert.AreEqual(1, Composed.Count);
-            Assert.AreEqual(typeof(Component10), Composed[0]);
+            Assert.AreEqual(typeof(Composer10), Composed[0]);
 
-            thing = new BootLoader(container);
+            types = new[] { typeof(Composer11) };
+            components = new Core.Components.Composers(composition, types, Mock.Of<IProfilingLogger>());
             Composed.Clear();
-            Assert.Throws<Exception>(() => thing.Boot(new[] { typeof(Component11) }, RuntimeLevel.Unknown));
+            Assert.Throws<Exception>(() => components.Compose());
 
-            thing = new BootLoader(container);
+            types = new[] { typeof(Composer2) };
+            components = new Core.Components.Composers(composition, types, Mock.Of<IProfilingLogger>());
             Composed.Clear();
-            Assert.Throws<Exception>(() => thing.Boot(new[] { typeof(Component2) }, RuntimeLevel.Unknown));
+            Assert.Throws<Exception>(() => components.Compose());
 
-            thing = new BootLoader(container);
+            types = new[] { typeof(Composer12) };
+            components = new Core.Components.Composers(composition, types, Mock.Of<IProfilingLogger>());
             Composed.Clear();
-            thing.Boot(new[] { typeof(Component12) }, RuntimeLevel.Unknown);
+            components.Compose();
             Assert.AreEqual(1, Composed.Count);
-            Assert.AreEqual(typeof(Component12), Composed[0]);
+            Assert.AreEqual(typeof(Composer12), Composed[0]);
         }
 
         [Test]
         public void DisableMissing()
         {
-            var container = MockContainer();
+            var register = MockRegister();
+            var composition = new Composition(register, MockTypeLoader(), Mock.Of<IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
 
-            var thing = new BootLoader(container);
+            var types = new[] { typeof(Composer6), typeof(Composer8) }; // 8 disables 7 which is not in the list
+            var components = new Core.Components.Composers(composition, types, Mock.Of<IProfilingLogger>());
             Composed.Clear();
-            thing.Boot(new[] { typeof(Component6), typeof(Component8) }, RuntimeLevel.Unknown); // 8 disables 7 which is not in the list
+            components.Compose();
             Assert.AreEqual(2, Composed.Count);
-            Assert.AreEqual(typeof(Component6), Composed[0]);
-            Assert.AreEqual(typeof(Component8), Composed[1]);
+            Assert.AreEqual(typeof(Composer6), Composed[0]);
+            Assert.AreEqual(typeof(Composer8), Composed[1]);
         }
 
         #region Components
 
-        public class TestComponentBase : UmbracoComponentBase
+        public class TestComposerBase : IComposer
         {
-            public override void Compose(Composition composition)
+            public virtual void Compose(Composition composition)
             {
-                base.Compose(composition);
                 Composed.Add(GetType());
             }
         }
 
-        public class Component1 : TestComponentBase
+        public class TestComponentBase : IComponent
         { }
 
-        [RequireComponent(typeof(Component4))]
-        public class Component2 : TestComponentBase, IUmbracoCoreComponent
+        public class Composer1 : TestComposerBase
         { }
 
-        public class Component3 : TestComponentBase, IUmbracoUserComponent
+        [ComposeAfter(typeof(Composer4))]
+        public class Composer2 : TestComposerBase, ICoreComposer
         { }
 
-        public class Component4 : TestComponentBase
+        public class Composer3 : TestComposerBase, IUserComposer
         { }
 
-        public class Component5 : TestComponentBase
+        public class Composer4 : TestComposerBase
+        { }
+
+        public class Composer5 : TestComposerBase
         {
-            public void Initialize(ISomeResource resource)
+            public override void Compose(Composition composition)
+            {
+                base.Compose(composition);
+                composition.Components().Append<Component5>();
+            }
+        }
+
+        public class Component5 : IComponent
+        {
+            public Component5(ISomeResource resource)
             {
                 Initialized.Add(resource.GetType().FullName);
             }
         }
 
-        [DisableComponent]
-        public class Component6 : TestComponentBase
+        [Disable]
+        public class Composer6 : TestComposerBase
         { }
 
-        public class Component7 : TestComponentBase
+        public class Composer7 : TestComposerBase
         { }
 
-        [DisableComponent(typeof(Component7))]
-        [EnableComponent(typeof(Component6))]
-        public class Component8 : TestComponentBase
+        [Disable(typeof(Composer7))]
+        [Enable(typeof(Composer6))]
+        public class Composer8 : TestComposerBase
         { }
 
-        public interface ITestComponent : IUmbracoUserComponent
+        public interface ITestComposer : IUserComposer
         { }
 
-        public class Component9 : TestComponentBase, ITestComponent
+        public class Composer9 : TestComposerBase, ITestComposer
         { }
 
-        [RequireComponent(typeof(ITestComponent))]
-        public class Component10 : TestComponentBase
+        [ComposeAfter(typeof(ITestComposer))]
+        public class Composer10 : TestComposerBase
         { }
 
-        [RequireComponent(typeof(ITestComponent), false)]
-        public class Component11 : TestComponentBase
+        [ComposeAfter(typeof(ITestComposer), false)]
+        public class Composer11 : TestComposerBase
         { }
 
-        [RequireComponent(typeof(Component4), true)]
-        public class Component12 : TestComponentBase, IUmbracoCoreComponent
+        [ComposeAfter(typeof(Composer4), true)]
+        public class Composer12 : TestComposerBase, ICoreComposer
         { }
 
-        [RequiredComponent(typeof(Component1))]
-        public class Component13 : TestComponentBase
+        [ComposeBefore(typeof(Composer1))]
+        public class Composer13 : TestComposerBase
         { }
 
         public interface ISomeResource { }
 
         public class SomeResource : ISomeResource { }
 
-        public class Component20 : TestComponentBase
+        public class Composer20 : TestComposerBase
         { }
 
-        [RequiredComponent(typeof(Component20))]
-        public class Component21 : TestComponentBase
+        [ComposeBefore(typeof(Composer20))]
+        public class Composer21 : TestComposerBase
         { }
 
-        public class Component22 : TestComponentBase
+        public class Composer22 : TestComposerBase
         { }
 
-        [RequireComponent(typeof(Component22))]
-        public interface IComponent23 : IUmbracoComponent
+        [ComposeAfter(typeof(Composer22))]
+        public interface IComposer23 : IComposer
         { }
 
-        public class Component24 : TestComponentBase, IComponent23
+        public class Composer24 : TestComposerBase, IComposer23
         { }
 
         // should insert itself between 22 and anything i23
-        [RequiredComponent(typeof(IComponent23))]
+        [ComposeBefore(typeof(IComposer23))]
         //[RequireComponent(typeof(Component22))] - not needed, implement i23
-        public class Component25 : TestComponentBase, IComponent23
+        public class Composer25 : TestComposerBase, IComposer23
         { }
 
         #endregion

src/Umbraco.Tests/Composing/CollectionBuildersTests.cs

@@ -1,39 +1,40 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using LightInject;
+using Moq;
 using NUnit.Framework;
 using Umbraco.Core.Composing;
+using Umbraco.Core;
+using Umbraco.Core.Components;
+using Umbraco.Core.Logging;
+using Umbraco.Tests.Components;
 
 namespace Umbraco.Tests.Composing
 {
     [TestFixture]
     public class CollectionBuildersTests
     {
-        private ServiceContainer _container;
+        private Composition _composition;
 
         [SetUp]
         public void Setup()
         {
             Current.Reset();
 
-            _container = new ServiceContainer();
-            _container.ConfigureUmbracoCore();
+            var register = RegisterFactory.Create();
+            _composition = new Composition(register, new TypeLoader(), Mock.Of<IProfilingLogger>(), ComponentTests.MockRuntimeState(RuntimeLevel.Run));
         }
 
         [TearDown]
         public void TearDown()
         {
             Current.Reset();
-
-            _container.Dispose();
-            _container = null;
         }
 
         [Test]
         public void ContainsTypes()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Append<Resolved1>()
                 .Append<Resolved2>();
 
@@ -42,14 +43,15 @@ namespace Umbraco.Tests.Composing
             Assert.IsFalse(builder.Has<Resolved3>());
             //Assert.IsFalse(col.ContainsType<Resolved4>()); // does not compile
 
-            var col = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+            var col = builder.CreateCollection(factory);
             AssertCollection(col, typeof(Resolved1), typeof(Resolved2));
         }
 
         [Test]
         public void CanClearBuilderBeforeCollectionIsCreated()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Append<Resolved1>()
                 .Append<Resolved2>();
 
@@ -57,18 +59,20 @@ namespace Umbraco.Tests.Composing
             Assert.IsFalse(builder.Has<Resolved1>());
             Assert.IsFalse(builder.Has<Resolved2>());
 
-            var col = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+            var col = builder.CreateCollection(factory);
             AssertCollection(col);
         }
 
         [Test]
         public void CannotClearBuilderOnceCollectionIsCreated()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Append<Resolved1>()
                 .Append<Resolved2>();
 
-            var col = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+            var col = builder.CreateCollection(factory);
 
             Assert.Throws<InvalidOperationException>(() => builder.Clear());
         }
@@ -76,7 +80,7 @@ namespace Umbraco.Tests.Composing
         [Test]
         public void CanAppendToBuilder()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>();
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>();
             builder.Append<Resolved1>();
             builder.Append<Resolved2>();
 
@@ -84,16 +88,18 @@ namespace Umbraco.Tests.Composing
             Assert.IsTrue(builder.Has<Resolved2>());
             Assert.IsFalse(builder.Has<Resolved3>());
 
-            var col = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+            var col = builder.CreateCollection(factory);
             AssertCollection(col, typeof(Resolved1), typeof(Resolved2));
         }
 
         [Test]
         public void CannotAppendToBuilderOnceCollectionIsCreated()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>();
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>();
 
-            var col = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+            var col = builder.CreateCollection(factory);
 
             Assert.Throws<InvalidOperationException>(() =>
                 builder.Append<Resolved1>()
@@ -103,18 +109,21 @@ namespace Umbraco.Tests.Composing
         [Test]
         public void CanAppendDuplicateToBuilderAndDeDuplicate()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>();
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>();
             builder.Append<Resolved1>();
             builder.Append<Resolved1>();
 
-            var col = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+
+            var col = builder.CreateCollection(factory);
             AssertCollection(col, typeof(Resolved1));
         }
 
         [Test]
         public void CannotAppendInvalidTypeToBUilder()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>();
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>();
+
             //builder.Append<Resolved4>(); // does not compile
             Assert.Throws<InvalidOperationException>(() =>
                     builder.Append(new[] { typeof (Resolved4) }) // throws
@@ -124,7 +133,7 @@ namespace Umbraco.Tests.Composing
         [Test]
         public void CanRemoveFromBuilder()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Append<Resolved1>()
                 .Append<Resolved2>()
                 .Remove<Resolved2>();
@@ -133,30 +142,33 @@ namespace Umbraco.Tests.Composing
             Assert.IsFalse(builder.Has<Resolved2>());
             Assert.IsFalse(builder.Has<Resolved3>());
 
-            var col = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+            var col = builder.CreateCollection(factory);
             AssertCollection(col, typeof(Resolved1));
         }
 
         [Test]
         public void CanRemoveMissingFromBuilder()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Append<Resolved1>()
                 .Append<Resolved2>()
                 .Remove<Resolved3>();
 
-            var col = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+            var col = builder.CreateCollection(factory);
             AssertCollection(col, typeof(Resolved1), typeof(Resolved2));
         }
 
         [Test]
         public void CannotRemoveFromBuilderOnceCollectionIsCreated()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Append<Resolved1>()
                 .Append<Resolved2>();
 
-            var col = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+            var col = builder.CreateCollection(factory);
             Assert.Throws<InvalidOperationException>(() =>
                 builder.Remove<Resolved2>() // throws
             );
@@ -165,7 +177,7 @@ namespace Umbraco.Tests.Composing
         [Test]
         public void CanInsertIntoBuilder()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Append<Resolved1>()
                 .Append<Resolved2>()
                 .Insert<Resolved3>();
@@ -174,18 +186,20 @@ namespace Umbraco.Tests.Composing
             Assert.IsTrue(builder.Has<Resolved2>());
             Assert.IsTrue(builder.Has<Resolved3>());
 
-            var col = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+            var col = builder.CreateCollection(factory);
             AssertCollection(col, typeof(Resolved3), typeof(Resolved1), typeof(Resolved2));
         }
 
         [Test]
         public void CannotInsertIntoBuilderOnceCollectionIsCreated()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Append<Resolved1>()
                 .Append<Resolved2>();
 
-            var col = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+            var col = builder.CreateCollection(factory);
             Assert.Throws<InvalidOperationException>(() =>
                 builder.Insert<Resolved3>() // throws
             );
@@ -194,29 +208,31 @@ namespace Umbraco.Tests.Composing
         [Test]
         public void CanInsertDuplicateIntoBuilderAndDeDuplicate()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Append<Resolved1>()
                 .Append<Resolved2>()
                 .Insert<Resolved2>();
 
-            var col = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+            var col = builder.CreateCollection(factory);
             AssertCollection(col, typeof(Resolved2), typeof(Resolved1));
         }
 
         [Test]
         public void CanInsertIntoEmptyBuilder()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>();
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>();
             builder.Insert<Resolved2>();
 
-            var col = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+            var col = builder.CreateCollection(factory);
             AssertCollection(col, typeof(Resolved2));
         }
 
         [Test]
         public void CannotInsertIntoBuilderAtWrongIndex()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Append<Resolved1>()
                 .Append<Resolved2>();
 
@@ -232,7 +248,7 @@ namespace Umbraco.Tests.Composing
         [Test]
         public void CanInsertIntoBuilderBefore()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Append<Resolved1>()
                 .Append<Resolved2>()
                 .InsertBefore<Resolved2, Resolved3>();
@@ -241,18 +257,20 @@ namespace Umbraco.Tests.Composing
             Assert.IsTrue(builder.Has<Resolved2>());
             Assert.IsTrue(builder.Has<Resolved3>());
 
-            var col = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+            var col = builder.CreateCollection(factory);
             AssertCollection(col, typeof(Resolved1), typeof(Resolved3), typeof(Resolved2));
         }
 
         [Test]
         public void CannotInsertIntoBuilderBeforeOnceCollectionIsCreated()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Append<Resolved1>()
                 .Append<Resolved2>();
 
-            var col = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+            var col = builder.CreateCollection(factory);
             Assert.Throws<InvalidOperationException>(() =>
                 builder.InsertBefore<Resolved2, Resolved3>()
             );
@@ -261,19 +279,20 @@ namespace Umbraco.Tests.Composing
         [Test]
         public void CanInsertDuplicateIntoBuilderBeforeAndDeDuplicate()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Append<Resolved1>()
                 .Append<Resolved2>()
                 .InsertBefore<Resolved1, Resolved2>();
 
-            var col = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+            var col = builder.CreateCollection(factory);
             AssertCollection(col, typeof(Resolved2), typeof(Resolved1));
         }
 
         [Test]
         public void CannotInsertIntoBuilderBeforeMissing()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Append<Resolved1>();
 
             Assert.Throws<InvalidOperationException>(() =>
@@ -284,7 +303,7 @@ namespace Umbraco.Tests.Composing
         [Test]
         public void ScopeBuilderCreatesScopedCollection()
         {
-            _container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            _composition.WithCollectionBuilder<TestCollectionBuilderScope>()
                 .Append<Resolved1>()
                 .Append<Resolved2>();
 
@@ -292,19 +311,25 @@ namespace Umbraco.Tests.Composing
             // but the container manages the scope, so to test the scope
             // the collection must come from the container
 
-            var col1 = _container.GetInstance<TestCollection>();
-            AssertCollection(col1, typeof(Resolved1), typeof(Resolved2));
+            var factory = _composition.CreateFactory();
 
-            var col2 = _container.GetInstance<TestCollection>();
-            AssertCollection(col2, typeof(Resolved1), typeof(Resolved2));
+            using (factory.BeginScope())
+            { 
+                var col1 = factory.GetInstance<TestCollection>();
+                AssertCollection(col1, typeof(Resolved1), typeof(Resolved2));
+
+                var col2 = factory.GetInstance<TestCollection>();
+                AssertCollection(col2, typeof(Resolved1), typeof(Resolved2));
+
+                AssertSameCollection(col1, col2);
+            }
 
-            AssertSameCollection(col1, col2);
         }
 
         [Test]
         public void TransientBuilderCreatesTransientCollection()
         {
-            _container.RegisterCollectionBuilder<TestCollectionBuilderTransient>()
+            _composition.WithCollectionBuilder<TestCollectionBuilderTransient>()
                 .Append<Resolved1>()
                 .Append<Resolved2>();
 
@@ -312,10 +337,12 @@ namespace Umbraco.Tests.Composing
             // but the container manages the scope, so to test the scope
             // the collection must come from the container
 
-            var col1 = _container.GetInstance<TestCollection>();
+            var factory = _composition.CreateFactory();
+
+            var col1 = factory.GetInstance<TestCollection>();
             AssertCollection(col1, typeof(Resolved1), typeof(Resolved2));
 
-            var col2 = _container.GetInstance<TestCollection>();
+            var col2 = factory.GetInstance<TestCollection>();
             AssertCollection(col1, typeof(Resolved1), typeof(Resolved2));
 
             AssertNotSameCollection(col1, col2);
@@ -324,19 +351,20 @@ namespace Umbraco.Tests.Composing
         [Test]
         public void BuilderRespectsTypesOrder()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilderTransient>()
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilderTransient>()
                 .Append<Resolved3>()
                 .Insert<Resolved1>()
                 .InsertBefore<Resolved3, Resolved2>();
 
-            var col1 = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+            var col1 = builder.CreateCollection(factory);
             AssertCollection(col1, typeof(Resolved1), typeof(Resolved2), typeof(Resolved3));
         }
 
         [Test]
         public void ScopeBuilderRespectsContainerScope()
         {
-            _container.RegisterCollectionBuilder<TestCollectionBuilderScope>()
+            _composition.WithCollectionBuilder<TestCollectionBuilderScope>()
                 .Append<Resolved1>()
                 .Append<Resolved2>();
 
@@ -344,34 +372,40 @@ namespace Umbraco.Tests.Composing
             // but the container manages the scope, so to test the scope
             // the collection must come from the container
 
-            var scope1 = _container.BeginScope();
+            TestCollection col1A, col1B;
+
+            var factory = _composition.CreateFactory();
+
+            using (factory.BeginScope())
+            {
+                col1A = factory.GetInstance<TestCollection>();
+                col1B = factory.GetInstance<TestCollection>();
+            }
 
-            var col1A = _container.GetInstance<TestCollection>();
             AssertCollection(col1A, typeof(Resolved1), typeof(Resolved2));
-            var col1B = _container.GetInstance<TestCollection>();
             AssertCollection(col1B, typeof(Resolved1), typeof(Resolved2));
-
             AssertSameCollection(col1A, col1B);
 
-            _container.ScopeManagerProvider.GetScopeManager(_container).CurrentScope.Dispose();
-            var scope2 = _container.BeginScope();
+            TestCollection col2;
+
+            using (factory.BeginScope())
+            {
+                col2 = factory.GetInstance<TestCollection>();
+            }
 
-            var col2 = _container.GetInstance<TestCollection>();
             AssertCollection(col2, typeof(Resolved1), typeof(Resolved2));
-
             AssertNotSameCollection(col1A, col2);
-
-            _container.ScopeManagerProvider.GetScopeManager(_container).CurrentScope.Dispose();
         }
 
         [Test]
         public void WeightedBuilderCreatesWeightedCollection()
         {
-            var builder = _container.RegisterCollectionBuilder<TestCollectionBuilderWeighted>()
+            var builder = _composition.WithCollectionBuilder<TestCollectionBuilderWeighted>()
                .Add<Resolved1>()
                .Add<Resolved2>();
 
-            var col = builder.CreateCollection();
+            var factory = _composition.CreateFactory();
+            var col = builder.CreateCollection(factory);
             AssertCollection(col, typeof(Resolved2), typeof(Resolved1));
         }
 
@@ -432,44 +466,28 @@ namespace Umbraco.Tests.Composing
         // ReSharper disable once ClassNeverInstantiated.Local
         private class TestCollectionBuilder : OrderedCollectionBuilderBase<TestCollectionBuilder, TestCollection, Resolved>
         {
-            public TestCollectionBuilder(IServiceContainer container)
-                : base(container)
-            { }
-
             protected override TestCollectionBuilder This => this;
         }
 
         // ReSharper disable once ClassNeverInstantiated.Local
         private class TestCollectionBuilderTransient : OrderedCollectionBuilderBase<TestCollectionBuilderTransient, TestCollection, Resolved>
         {
-            public TestCollectionBuilderTransient(IServiceContainer container)
-                : base(container)
-            { }
-
             protected override TestCollectionBuilderTransient This => this;
 
-            protected override ILifetime CollectionLifetime => null; // transient
+            protected override Lifetime CollectionLifetime => Lifetime.Transient; // transient
         }
 
         // ReSharper disable once ClassNeverInstantiated.Local
         private class TestCollectionBuilderScope : OrderedCollectionBuilderBase<TestCollectionBuilderScope, TestCollection, Resolved>
         {
-            public TestCollectionBuilderScope(IServiceContainer container)
-                : base(container)
-            { }
-
             protected override TestCollectionBuilderScope This => this;
 
-            protected override ILifetime CollectionLifetime => new PerScopeLifetime();
+            protected override Lifetime CollectionLifetime => Lifetime.Scope;
         }
 
         // ReSharper disable once ClassNeverInstantiated.Local
         private class TestCollectionBuilderWeighted : WeightedCollectionBuilderBase<TestCollectionBuilderWeighted, TestCollection, Resolved>
         {
-            public TestCollectionBuilderWeighted(IServiceContainer container)
-                : base(container)
-            { }
-
             protected override TestCollectionBuilderWeighted This => this;
         }
 

src/Umbraco.Tests/Composing/ComposingTestBase.cs

@@ -4,6 +4,7 @@ using Moq;
 using NUnit.Framework;
 using Umbraco.Core.Cache;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Tests.TestHelpers;
 
@@ -13,14 +14,14 @@ namespace Umbraco.Tests.Composing
     {
         protected TypeLoader TypeLoader { get; private set; }
 
-        protected ProfilingLogger ProfilingLogger { get; private set; }
+        protected IProfilingLogger ProfilingLogger { get; private set; }
 
         [SetUp]
         public void Initialize()
         {
             ProfilingLogger = new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>());
 
-            TypeLoader = new TypeLoader(NullCacheProvider.Instance, SettingsForTests.GenerateMockGlobalSettings(), ProfilingLogger, detectChanges: false)
+            TypeLoader = new TypeLoader(NullCacheProvider.Instance, LocalTempStorage.Default, ProfilingLogger, detectChanges: false)
             {
                 AssembliesToScan = AssembliesToScan
             };

src/Umbraco.Tests/Composing/ContainerConformingTests.cs

@@ -0,0 +1,356 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Umbraco.Core.Composing;
+
+namespace Umbraco.Tests.Composing
+{
+    [TestFixture]
+    public class ContainerConformingTests
+    {
+        // tests that a container conforms
+
+        private IRegister GetRegister() => RegisterFactory.Create();
+
+        [Test]
+        public void CanRegisterAndGet()
+        {
+            var register = GetRegister();
+
+            register.Register<Thing1>();
+
+            var factory = register.CreateFactory();
+
+            var thing = factory.GetInstance<Thing1>();
+            Assert.IsNotNull(thing);
+            Assert.IsInstanceOf<Thing1>(thing);
+        }
+
+        [Test]
+        public void CanRegisterAndGetLazy()
+        {
+            var register = GetRegister();
+
+            register.Register<Thing1>();
+
+            var factory = register.CreateFactory();
+
+            var lazyThing = factory.GetInstance<Lazy<Thing1>>();
+            Assert.IsNotNull(lazyThing);
+            Assert.IsInstanceOf<Lazy<Thing1>>(lazyThing);
+            var thing = lazyThing.Value;
+            Assert.IsNotNull(thing);
+            Assert.IsInstanceOf<Thing1>(thing);
+        }
+
+        [Test]
+        public void CannotRegistedAndGetBase()
+        {
+            var register = GetRegister();
+
+            register.Register<Thing1>();
+
+            var factory = register.CreateFactory();
+
+            Assert.IsNull(factory.TryGetInstance<ThingBase>());
+        }
+
+        [Test]
+        public void CannotRegisterAndGetInterface()
+        {
+            var register = GetRegister();
+
+            register.Register<Thing1>();
+
+            var factory = register.CreateFactory();
+
+            Assert.IsNull(factory.TryGetInstance<IThing>());
+        }
+
+        [Test]
+        public void CanRegisterAndGetAllBase()
+        {
+            var register = GetRegister();
+
+            register.Register<Thing1>();
+
+            var factory = register.CreateFactory();
+
+            var things = factory.GetAllInstances<ThingBase>();
+            Assert.AreEqual(1, things.Count());
+
+            // lightInject: would be zero with option EnableVariance set to false
+        }
+
+        [Test]
+        public void CanRegisterAndGetAllInterface()
+        {
+            var register = GetRegister();
+
+            register.Register<Thing1>();
+
+            var factory = register.CreateFactory();
+
+            var things = factory.GetAllInstances<IThing>();
+            Assert.AreEqual(1, things.Count());
+
+            // lightInject: would be zero with option EnableVariance set to false
+        }
+
+        [Test]
+        public void CanRegisterBaseAndGet()
+        {
+            var register = GetRegister();
+
+            register.Register<ThingBase, Thing1>();
+
+            var factory = register.CreateFactory();
+
+            var thing = factory.GetInstance<ThingBase>();
+            Assert.IsNotNull(thing);
+            Assert.IsInstanceOf<Thing1>(thing);
+        }
+
+        [Test]
+        public void CanRegisterInterfaceAndGet()
+        {
+            var register = GetRegister();
+
+            register.Register<IThing, Thing1>();
+
+            var factory = register.CreateFactory();
+
+            var thing = factory.GetInstance<IThing>();
+            Assert.IsNotNull(thing);
+            Assert.IsInstanceOf<Thing1>(thing);
+        }
+
+        [Test]
+        public void NonSingletonServiceIsNotUnique()
+        {
+            var register = GetRegister();
+
+            register.Register<IThing, Thing1>();
+            register.Register<IThing, Thing2>();
+
+            var factory = register.CreateFactory();
+
+            var things = factory.GetInstance<IEnumerable<IThing>>();
+            Assert.AreEqual(2, things.Count());
+
+            Assert.IsNull(factory.TryGetInstance<IThing>());
+        }
+
+        [Test]
+        public void SingletonServiceIsUnique() // fixme - but what is LightInject actually doing
+        {
+            var register = GetRegister();
+
+            // fixme
+            // LightInject is 'unique' per serviceType+serviceName
+            // but that's not how all containers work
+            // and we should not rely on it
+            // if we need unique, use RegisterUnique
+
+            // for Core services that ppl may want to redefine in components,
+            // it is important to be able to have a unique, singleton implementation,
+            // and to redefine it - how it's done at container's level depends
+            // on each container
+
+            // redefine the service
+            register.Register<IThing, Thing1>(Lifetime.Singleton);
+            register.Register<IThing, Thing2>(Lifetime.Singleton);
+
+            var factory = register.CreateFactory();
+
+            var things = factory.GetInstance<IEnumerable<IThing>>();
+            Assert.AreEqual(1, things.Count());
+
+            var thing = factory.GetInstance<IThing>();
+            Assert.IsInstanceOf<Thing2>(thing);
+        }
+
+        [Test]
+        public void SingletonImplementationIsNotUnique()
+        {
+            var register = GetRegister();
+
+            // define two implementations
+            register.Register<Thing1>(Lifetime.Singleton);
+            register.Register<Thing2>(Lifetime.Singleton);
+
+            var factory = register.CreateFactory();
+
+            var things = factory.GetInstance<IEnumerable<IThing>>();
+            Assert.AreEqual(2, things.Count());
+
+            Assert.IsNull(factory.TryGetInstance<IThing>());
+        }
+
+        [Test]
+        public void ActualInstanceIsNotUnique()
+        {
+            var register = GetRegister();
+
+            // define two instances
+            register.RegisterInstance(typeof(Thing1), new Thing1());
+            register.RegisterInstance(typeof(Thing1), new Thing2());
+
+            var factory = register.CreateFactory();
+
+            var things = factory.GetInstance<IEnumerable<IThing>>();
+            //Assert.AreEqual(2, things.Count());
+            Assert.AreEqual(1, things.Count()); // well, yes they are unique?
+
+            Assert.IsNull(factory.TryGetInstance<IThing>());
+        }
+
+        [Test]
+        public void InterfaceInstanceIsNotUnique()
+        {
+            var register = GetRegister();
+
+            // define two instances
+            register.RegisterInstance(typeof(IThing), new Thing1());
+            register.RegisterInstance(typeof(IThing), new Thing2());
+
+            var factory = register.CreateFactory();
+
+            var things = factory.GetInstance<IEnumerable<IThing>>();
+            //Assert.AreEqual(2, things.Count());
+            Assert.AreEqual(1, things.Count()); // well, yes they are unique?
+
+            //Assert.IsNull(factory.TryGetInstance<IThing>());
+            Assert.IsNotNull(factory.TryGetInstance<IThing>()); // well, what?
+        }
+
+        [Test]
+        public void CanInjectEnumerableOfBase()
+        {
+            var register = GetRegister();
+
+            register.Register<Thing1>();
+            register.Register<Thing2>();
+            register.Register<NeedThings>();
+
+            var factory = register.CreateFactory();
+
+            var needThings = factory.GetInstance<NeedThings>();
+            Assert.AreEqual(2, needThings.Things.Count());
+        }
+
+        [Test]
+        public void CanGetEnumerableOfBase()
+        {
+            var register = GetRegister();
+
+            register.Register<Thing1>();
+            register.Register<Thing2>();
+
+            var factory = register.CreateFactory();
+
+            var things = factory.GetInstance<IEnumerable<ThingBase>>();
+            Assert.AreEqual(2, things. Count());
+        }
+
+        [Test]
+        public void CanGetEmptyEnumerableOfBase()
+        {
+            var register = GetRegister();
+            var factory = register.CreateFactory();
+
+            var things = factory.GetInstance<IEnumerable<ThingBase>>();
+            Assert.AreEqual(0, things.Count());
+        }
+
+        [Test]
+        public void CanGetEmptyAllInstancesOfBase()
+        {
+            var register = GetRegister();
+            var factory = register.CreateFactory();
+
+            var things = factory.GetAllInstances<ThingBase>();
+            Assert.AreEqual(0, things.Count());
+        }
+
+        [Test]
+        public void CanTryGetEnumerableOfBase()
+        {
+            var register = GetRegister();
+
+            register.Register<Thing1>();
+            register.Register<Thing2>();
+
+            var factory = register.CreateFactory();
+
+            var things = factory.TryGetInstance<IEnumerable<ThingBase>>();
+            Assert.AreEqual(2, things.Count());
+        }
+
+        [Test]
+        public void CanRegisterSingletonInterface()
+        {
+            var register = GetRegister();
+            register.Register<IThing, Thing1>(Lifetime.Singleton);
+            var factory = register.CreateFactory();
+            var s1 = factory.GetInstance<IThing>();
+            var s2 = factory.GetInstance<IThing>();
+            Assert.AreSame(s1, s2);
+        }
+
+        [Test]
+        public void CanRegisterSingletonClass()
+        {
+            var register = GetRegister();
+            register.Register<Thing1>(Lifetime.Singleton);
+            var factory = register.CreateFactory();
+            var s1 = factory.GetInstance<Thing1>();
+            var s2 = factory.GetInstance<Thing1>();
+            Assert.AreSame(s1, s2);
+        }
+
+        [Test]
+        public void CanReRegisterSingletonInterface()
+        {
+            var register = GetRegister();
+            register.Register<IThing, Thing1>(Lifetime.Singleton);
+            register.Register<IThing, Thing2>(Lifetime.Singleton);
+            var factory = register.CreateFactory();
+            var s = factory.GetInstance<IThing>();
+            Assert.IsInstanceOf<Thing2>(s);
+        }
+
+        [Test]
+        public void CanRegisterSingletonWithCreate()
+        {
+            var register = GetRegister();
+            register.Register(c => c.CreateInstance<Thing3>(new Thing1()), Lifetime.Singleton);
+            var factory = register.CreateFactory();
+            var s1 = factory.GetInstance<Thing3>();
+            var s2 = factory.GetInstance<Thing3>();
+            Assert.AreSame(s1, s2);
+        }
+
+        public interface IThing { }
+
+        public abstract class ThingBase : IThing { }
+        public class Thing1 : ThingBase { }
+        public class Thing2 : ThingBase { }
+
+        public class Thing3 : ThingBase
+        {
+            public Thing3(Thing1 thing) { }
+        }
+
+        public class NeedThings
+        {
+            public NeedThings(IEnumerable<ThingBase> things)
+            {
+                Things = things;
+            }
+
+            public IEnumerable<ThingBase> Things { get; }
+        }
+    }
+}

src/Umbraco.Tests/Composing/LazyCollectionBuilderTests.cs

@@ -1,10 +1,15 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using LightInject;
+using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
+using Umbraco.Core.Cache;
+using Umbraco.Core.Components;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.Logging;
+using Umbraco.Tests.Components;
 
 namespace Umbraco.Tests.Composing
 {
@@ -23,6 +28,11 @@ namespace Umbraco.Tests.Composing
             Current.Reset();
         }
 
+        private IRegister CreateRegister()
+        {
+            return RegisterFactory.Create();
+        }
+
         // note
         // lazy collection builder does not throw on duplicate, just uses distinct types
         // so we don't have a test for duplicates as we had with resolvers in v7
@@ -30,22 +40,24 @@ namespace Umbraco.Tests.Composing
         [Test]
         public void LazyCollectionBuilderHandlesTypes()
         {
-            var container = new ServiceContainer();
-            container.ConfigureUmbracoCore();
+            var container = CreateRegister();
+            var composition = new Composition(container, new TypeLoader(), Mock.Of<IProfilingLogger>(), ComponentTests.MockRuntimeState(RuntimeLevel.Run));
 
-            container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Add<TransientObject3>()
                 .Add<TransientObject2>()
                 .Add<TransientObject3>()
                 .Add<TransientObject1>();
 
-            var values = container.GetInstance<TestCollection>();
+            var factory = composition.CreateFactory();
+
+            var values = factory.GetInstance<TestCollection>();
 
             Assert.AreEqual(3, values.Count());
             Assert.IsTrue(values.Select(x => x.GetType())
                 .ContainsAll(new[] { typeof(TransientObject1), typeof(TransientObject2), typeof(TransientObject3) }));
 
-            var other = container.GetInstance<TestCollection>();
+            var other = factory.GetInstance<TestCollection>();
             Assert.AreNotSame(values, other); // transient
             var o1 = other.FirstOrDefault(x => x is TransientObject1);
             Assert.IsFalse(values.Contains(o1)); // transient
@@ -54,21 +66,23 @@ namespace Umbraco.Tests.Composing
         [Test]
         public void LazyCollectionBuilderHandlesProducers()
         {
-            var container = new ServiceContainer();
-            container.ConfigureUmbracoCore();
+            var container = CreateRegister();
+            var composition = new Composition(container, new TypeLoader(), Mock.Of<IProfilingLogger>(), ComponentTests.MockRuntimeState(RuntimeLevel.Run));
 
-            container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Add(() => new[] { typeof(TransientObject3), typeof(TransientObject2) })
                 .Add(() => new[] { typeof(TransientObject3), typeof(TransientObject2) })
                 .Add(() => new[] { typeof(TransientObject1) });
 
-            var values = container.GetInstance<TestCollection>();
+            var factory = composition.CreateFactory();
+
+            var values = factory.GetInstance<TestCollection>();
 
             Assert.AreEqual(3, values.Count());
             Assert.IsTrue(values.Select(x => x.GetType())
                 .ContainsAll(new[] { typeof(TransientObject1), typeof(TransientObject2), typeof(TransientObject3) }));
 
-            var other = container.GetInstance<TestCollection>();
+            var other = factory.GetInstance<TestCollection>();
             Assert.AreNotSame(values, other); // transient
             var o1 = other.FirstOrDefault(x => x is TransientObject1);
             Assert.IsFalse(values.Contains(o1)); // transient
@@ -77,22 +91,24 @@ namespace Umbraco.Tests.Composing
         [Test]
         public void LazyCollectionBuilderHandlesTypesAndProducers()
         {
-            var container = new ServiceContainer();
-            container.ConfigureUmbracoCore();
+            var container = CreateRegister();
+            var composition = new Composition(container, new TypeLoader(), Mock.Of<IProfilingLogger>(), ComponentTests.MockRuntimeState(RuntimeLevel.Run));
 
-            container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Add<TransientObject3>()
                 .Add<TransientObject2>()
                 .Add<TransientObject3>()
                 .Add(() => new[] { typeof(TransientObject1) });
 
-            var values = container.GetInstance<TestCollection>();
+            var factory = composition.CreateFactory();
+
+            var values = factory.GetInstance<TestCollection>();
 
             Assert.AreEqual(3, values.Count());
             Assert.IsTrue(values.Select(x => x.GetType())
                 .ContainsAll(new[] { typeof(TransientObject1), typeof(TransientObject2), typeof(TransientObject3) }));
 
-            var other = container.GetInstance<TestCollection>();
+            var other = factory.GetInstance<TestCollection>();
             Assert.AreNotSame(values, other); // transient
             var o1 = other.FirstOrDefault(x => x is TransientObject1);
             Assert.IsFalse(values.Contains(o1)); // transient
@@ -101,10 +117,10 @@ namespace Umbraco.Tests.Composing
         [Test]
         public void LazyCollectionBuilderThrowsOnIllegalTypes()
         {
-            var container = new ServiceContainer();
-            container.ConfigureUmbracoCore();
+            var container = CreateRegister();
+            var composition = new Composition(container, new TypeLoader(), Mock.Of<IProfilingLogger>(), ComponentTests.MockRuntimeState(RuntimeLevel.Run));
 
-            container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Add<TransientObject3>()
 
                 // illegal, does not implement the interface!
@@ -115,23 +131,25 @@ namespace Umbraco.Tests.Composing
 
             Assert.Throws<InvalidOperationException>(() =>
             {
-                // but throws here when trying to register the types
-                var values = container.GetInstance<TestCollection>();
+                // but throws here when trying to register the types, right before creating the factory
+                var factory = composition.CreateFactory();
             });
         }
 
         [Test]
         public void LazyCollectionBuilderCanExcludeTypes()
         {
-            var container = new ServiceContainer();
-            container.ConfigureUmbracoCore();
+            var container = CreateRegister();
+            var composition = new Composition(container, new TypeLoader(), Mock.Of<IProfilingLogger>(), ComponentTests.MockRuntimeState(RuntimeLevel.Run));
 
-            container.RegisterCollectionBuilder<TestCollectionBuilder>()
+            composition.WithCollectionBuilder<TestCollectionBuilder>()
                 .Add<TransientObject3>()
                 .Add(() => new[] { typeof(TransientObject3), typeof(TransientObject2), typeof(TransientObject1) })
                 .Exclude<TransientObject3>();
 
-            var values = container.GetInstance<TestCollection>();
+            var factory = composition.CreateFactory();
+
+            var values = factory.GetInstance<TestCollection>();
 
             Assert.AreEqual(2, values.Count());
             Assert.IsFalse(values.Select(x => x.GetType())
@@ -139,7 +157,7 @@ namespace Umbraco.Tests.Composing
             Assert.IsTrue(values.Select(x => x.GetType())
                 .ContainsAll(new[] { typeof(TransientObject1), typeof(TransientObject2) }));
 
-            var other = container.GetInstance<TestCollection>();
+            var other = factory.GetInstance<TestCollection>();
             Assert.AreNotSame(values, other); // transient
             var o1 = other.FirstOrDefault(x => x is TransientObject1);
             Assert.IsFalse(values.Contains(o1)); // transient
@@ -165,13 +183,9 @@ namespace Umbraco.Tests.Composing
         // ReSharper disable once ClassNeverInstantiated.Local
         private class TestCollectionBuilder : LazyCollectionBuilderBase<TestCollectionBuilder, TestCollection, ITestInterface>
         {
-            public TestCollectionBuilder(IServiceContainer container)
-                : base(container)
-            { }
-
             protected override TestCollectionBuilder This => this;
 
-            protected override ILifetime CollectionLifetime => null; // transient
+            protected override Lifetime CollectionLifetime => Lifetime.Transient; // transient
         }
 
         // ReSharper disable once ClassNeverInstantiated.Local

src/Umbraco.Tests/Composing/LightInjectValidation.cs

@@ -0,0 +1,349 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using LightInject;
+using System.Collections.Concurrent;
+using System.Collections.ObjectModel;
+using System.Reflection;
+using ServiceMap = System.Collections.Generic.Dictionary<System.Type, System.Collections.Generic.Dictionary<string, LightInject.ServiceRegistration>>;
+
+/*********************************************************************************
+    The MIT License (MIT)
+
+    Copyright (c) 2017 bernhard.richter@gmail.com
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+******************************************************************************
+    LightInject.Validation version 1.0.1
+    http://www.lightinject.net/
+    http://twitter.com/bernhardrichter
+******************************************************************************/
+
+namespace Umbraco.Tests.Composing
+{
+    public static class LightInjectValidation
+    {
+        private static readonly ConcurrentDictionary<Type, int> LifeSpans = new ConcurrentDictionary<Type, int>();
+
+        private const string NotDisposeMessageServiceType =
+            @"The service {0} is being injected as a constructor argument into {1} implements IDisposable, " +
+            "but is registered without a lifetime (transient). LightInject will not be able to dispose the instance represented by {0}. " +
+            "If the intent was to manually control the instantiation and destruction, inject Func<{0}> instead. " +
+            "Otherwise register `{0}` with a lifetime (PerContainer, PerRequest or PerScope).";
+
+        private const string NotDisposeMessageImplementingType =
+            @"The service {0} represented by {1} is being injected as a constructor argument into {2} implements IDisposable, " +
+            "but is registered without a lifetime (transient). LightInject will not be able to dispose the instance represented by {0}. " +
+            "If the intent was to manually control the instantiation and destruction, inject Func<{0}> instead. " +
+            "Otherwise register `{0}` with a lifetime (PerContainer, PerRequest or PerScope).";
+
+
+        private const string MissingDeferredDependency =
+            @"The injected '{0}' does not contain a registration for the underlying type '{1}'. " +
+            "Ensure that '{1}' is registered so that the service can be resolved by '{0}'";
+
+        /*
+        The service 'NameSpace.IBar' that is being injected into 'NameSpace.Foo' is registered with
+with a 'Transient' lifetime while the 'NameSpace.Foo' is registered with the 'PerScope' lifetime.
+Ensure that 'NameSpace.IBar' is registered with a lifetime that is equal to or has a longer lifetime than the 'PerScope' lifetime.
+        */
+        private const string CaptiveDependency =
+            @"The service '{0}' that is being injected into {1} is registered with " +
+            "a '{2}' lifetime while the {1} is registered with the '{3}' lifetime. " +
+            "Ensure that '{0}' is registered with a lifetime that is equal to or has a longer lifetime than the '{3}' lifetime. " +
+            "Alternatively ensure that `{1}` is registered with a lifetime that is equal to or " +
+            "has a shorter lifetime than `{2}` lifetime.";
+
+        private const string MissingDependency =
+                "Class: 'NameSpace.Foo', Parameter 'NameSpace.IBar bar' -> The injected service NameSpace IBar is not registered."
+            ;
+
+
+        static LightInjectValidation()
+        {
+            LifeSpans.TryAdd(typeof(PerRequestLifeTime), 10);
+            LifeSpans.TryAdd(typeof(PerScopeLifetime), 20);
+            LifeSpans.TryAdd(typeof(PerContainerLifetime), 30);
+        }
+
+        public static IEnumerable<ValidationResult> Validate(this ServiceContainer container)
+        {
+            var serviceMap = container.AvailableServices.GroupBy(sr => sr.ServiceType).ToDictionary(gr => gr.Key,
+                gr => gr.ToDictionary(sr => sr.ServiceName, sr => sr, StringComparer.OrdinalIgnoreCase));
+
+            var verifyableServices = container.AvailableServices.Where(sr => sr.ImplementingType != null);
+
+            return verifyableServices.SelectMany(sr =>
+                ValidateConstructor(serviceMap, sr, container.ConstructorSelector.Execute(sr.ImplementingType)));
+        }
+
+        private static IReadOnlyCollection<ValidationResult> ValidateConstructor(ServiceMap serviceMap,
+            ServiceRegistration serviceRegistration, ConstructorInfo constructorInfo)
+        {
+            var result = new Collection<ValidationResult>();
+
+            foreach (var parameter in constructorInfo.GetParameters())
+            {
+                var validationTarget = new ValidationTarget(serviceRegistration, parameter);
+                Validate(validationTarget, serviceMap, result);
+            }
+            return result;
+        }
+
+        private static void Validate(ValidationTarget validationTarget, ServiceMap serviceMap, ICollection<ValidationResult> result)
+        {
+            var registration = GetServiceRegistration(serviceMap, validationTarget);
+            if (registration == null)
+            {
+                if (validationTarget.ServiceType.IsFunc() || validationTarget.ServiceType.IsLazy())
+                {
+                    var serviceType = validationTarget.ServiceType.GenericTypeArguments[0];
+                    var underlyingvalidationTarget = validationTarget.WithServiceDescription(serviceType, string.Empty);
+                    registration = GetServiceRegistration(serviceMap, underlyingvalidationTarget);
+
+                    if (registration != null)
+                    {
+                        return;
+                    }
+
+                    if (serviceMap.ContainsAmbiguousRegistrationFor(serviceType))
+                    {
+                        result.Add(new ValidationResult("", ValidationSeverity.Ambiguous, underlyingvalidationTarget));
+                    }
+                    else
+                    {
+                        string message = string.Format(MissingDeferredDependency, validationTarget.ServiceType, underlyingvalidationTarget.ServiceType);
+                        result.Add(new ValidationResult(message, ValidationSeverity.MissingDependency, underlyingvalidationTarget));
+                    }
+                }
+                else if (validationTarget.ServiceType.IsGenericType && validationTarget.ServiceType.GetGenericTypeDefinition() == typeof(IEnumerable<>))
+                {
+                    var serviceType = validationTarget.ServiceType.GenericTypeArguments[0];
+                    var underlyingvalidationTarget = validationTarget.WithServiceDescription(serviceType, string.Empty);
+                    var registrations = GetServiceRegistrations(serviceMap, underlyingvalidationTarget);
+                    if (registrations.Any()) return;
+
+                    // strict: there has to be at least 1
+                    string message = string.Format(MissingDeferredDependency, validationTarget.ServiceType, underlyingvalidationTarget.ServiceType);
+                    result.Add(new ValidationResult(message, ValidationSeverity.MissingDependency, underlyingvalidationTarget));
+                }
+                else
+                {
+                    if (serviceMap.ContainsAmbiguousRegistrationFor(validationTarget.ServiceType))
+                    {
+                        result.Add(new ValidationResult("", ValidationSeverity.Ambiguous, validationTarget));
+                    }
+                    else
+                    {
+                        result.Add(new ValidationResult("", ValidationSeverity.MissingDependency, validationTarget));
+                    }
+                }
+            }
+            else
+            {
+                ValidateDisposable(validationTarget, result, registration);
+                ValidateLifetime(validationTarget, registration, result);
+            }
+        }
+
+        private static void ValidateDisposable(ValidationTarget validationTarget, ICollection<ValidationResult> result,
+            ServiceRegistration registration)
+        {
+            if (registration.ServiceType.Implements<IDisposable>())
+            {
+                var message = string.Format(NotDisposeMessageServiceType, registration.ServiceType,
+                    validationTarget.DeclaringService.ImplementingType);
+                result.Add(new ValidationResult(message, ValidationSeverity.NotDisposed, validationTarget));
+            }
+
+            else if (registration.ImplementingType != null && registration.ImplementingType.Implements<IDisposable>())
+            {
+                var message = string.Format(NotDisposeMessageImplementingType, registration.ImplementingType,
+                    registration.ServiceType,
+                    validationTarget.DeclaringService.ImplementingType);
+                result.Add(new ValidationResult(message, ValidationSeverity.NotDisposed, validationTarget));
+            }
+        }
+
+
+        private static void ValidateLifetime(ValidationTarget validationTarget, ServiceRegistration dependencyRegistration, ICollection<ValidationResult> result)
+        {
+            if (GetLifespan(validationTarget.DeclaringService.Lifetime) > GetLifespan(dependencyRegistration.Lifetime))
+            {
+                var message = string.Format(CaptiveDependency, dependencyRegistration.ServiceType,
+                    validationTarget.DeclaringService.ServiceType, GetLifetimeName(dependencyRegistration.Lifetime),
+                    GetLifetimeName(validationTarget.DeclaringService.Lifetime));
+                result.Add(new ValidationResult(message, ValidationSeverity.Captive, validationTarget));
+            }
+        }
+
+        public static void SetLifespan<TLifetime>(int lifeSpan) where TLifetime : ILifetime
+        {
+            LifeSpans.TryAdd(typeof(TLifetime), lifeSpan);
+        }
+
+        private static IEnumerable<ServiceRegistration> GetServiceRegistrations(ServiceMap serviceMap, ValidationTarget validationTarget)
+        {
+            return serviceMap.Where(x => validationTarget.ServiceType.IsAssignableFrom(x.Key)).SelectMany(x => x.Value.Values);
+        }
+
+        private static ServiceRegistration GetServiceRegistration(ServiceMap serviceMap, ValidationTarget validationTarget)
+        {
+            if (!serviceMap.TryGetValue(validationTarget.ServiceType, out var registrations))
+            {
+                return null;
+            }
+
+            if (registrations.TryGetValue(string.Empty, out var registration))
+            {
+                return registration;
+            }
+
+            if (registrations.Count == 1)
+            {
+                return registrations.Values.First();
+            }
+
+            if (registrations.TryGetValue(validationTarget.ServiceName, out registration))
+            {
+                return registration;
+            }
+
+            return null;
+        }
+
+        private static string GetLifetimeName(ILifetime lifetime)
+        {
+            if (lifetime == null)
+            {
+                return "Transient";
+            }
+            return lifetime.GetType().Name;
+        }
+
+        private static int GetLifespan(ILifetime lifetime)
+        {
+            if (lifetime == null)
+            {
+                return 0;
+            }
+            if (LifeSpans.TryGetValue(lifetime.GetType(), out var lifespan))
+            {
+                return lifespan;
+            }
+            return 0;
+        }
+    }
+
+
+    public class ValidationTarget
+    {
+        public ServiceRegistration DeclaringService { get; }
+        public ParameterInfo Parameter { get; }
+        public Type ServiceType { get; }
+        public string ServiceName { get; }
+
+
+        public ValidationTarget(ServiceRegistration declaringRegistration, ParameterInfo parameter) : this(declaringRegistration, parameter, parameter.ParameterType, string.Empty)
+        {
+        }
+
+
+        public ValidationTarget(ServiceRegistration declaringService, ParameterInfo parameter, Type serviceType, string serviceName)
+        {
+            DeclaringService = declaringService;
+            Parameter = parameter;
+            ServiceType = serviceType;
+            ServiceName = serviceName;
+
+
+            if (serviceType.GetTypeInfo().IsGenericType && serviceType.GetTypeInfo().ContainsGenericParameters)
+            {
+                ServiceType = serviceType.GetGenericTypeDefinition();
+            }
+
+        }
+
+        public ValidationTarget WithServiceDescription(Type serviceType, string serviceName)
+        {
+            return new ValidationTarget(DeclaringService, Parameter, serviceType, serviceName);
+        }
+
+    }
+
+
+
+
+
+    public class ValidationResult
+    {
+        public ValidationResult(string message, ValidationSeverity severity, ValidationTarget validationTarget)
+        {
+            Message = message;
+            Severity = severity;
+            ValidationTarget = validationTarget;
+        }
+
+        public string Message { get; }
+
+        public ValidationSeverity Severity { get; }
+        public ValidationTarget ValidationTarget { get; }
+    }
+
+    public enum ValidationSeverity
+    {
+        NoIssues,
+        Captive,
+        NotDisposed,
+        MissingDependency,
+        Ambiguous
+    }
+
+    internal static class TypeExtensions
+    {
+        public static bool Implements<TBaseType>(this Type type)
+        {
+            return type.GetTypeInfo().ImplementedInterfaces.Contains(typeof(TBaseType));
+        }
+
+        public static bool IsFunc(this Type type)
+        {
+            var typeInfo = type.GetTypeInfo();
+            return typeInfo.IsGenericType && typeInfo.GetGenericTypeDefinition() == typeof(Func<>);
+        }
+
+        public static bool IsLazy(this Type type)
+        {
+            var typeInfo = type.GetTypeInfo();
+            return typeInfo.IsGenericType && typeInfo.GetGenericTypeDefinition() == typeof(Lazy<>);
+        }
+    }
+
+    internal static class ServiceMapExtensions
+    {
+        public static bool ContainsAmbiguousRegistrationFor(this ServiceMap serviceMap, Type serviceType)
+        {
+            if (!serviceMap.TryGetValue(serviceType, out var registrations))
+            {
+                return false;
+            }
+            return registrations.Count > 1;
+        }
+    }
+}

src/Umbraco.Tests/Composing/PackageActionCollectionTests.cs

@@ -1,10 +1,14 @@
 using System;
 using System.Linq;
 using System.Xml;
-using LightInject;
+using Moq;
 using NUnit.Framework;
+using Umbraco.Core;
+using Umbraco.Core.Components;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Logging;
 using Umbraco.Core._Legacy.PackageActions;
+using Umbraco.Tests.Components;
 
 namespace Umbraco.Tests.Composing
 {
@@ -14,18 +18,21 @@ namespace Umbraco.Tests.Composing
         [Test]
         public void PackageActionCollectionBuilderWorks()
         {
-            var container = new ServiceContainer();
-            container.ConfigureUmbracoCore();
+            var container = RegisterFactory.Create();
+            
+            var composition = new Composition(container, new TypeLoader(), Mock.Of<IProfilingLogger>(), ComponentTests.MockRuntimeState(RuntimeLevel.Run));
 
-            container.RegisterCollectionBuilder<PackageActionCollectionBuilder>()
+            composition.WithCollectionBuilder<PackageActionCollectionBuilder>()
                 .Add(() => TypeLoader.GetPackageActions());
 
+            Current.Factory = composition.CreateFactory();
+
             var actions = Current.PackageActions;
             Assert.AreEqual(2, actions.Count());
 
             // order is unspecified, but both must be there
-            bool hasAction1 = actions.ElementAt(0) is PackageAction1 || actions.ElementAt(1) is PackageAction1;
-            bool hasAction2 = actions.ElementAt(0) is PackageAction2 || actions.ElementAt(1) is PackageAction2;
+            var hasAction1 = actions.ElementAt(0) is PackageAction1 || actions.ElementAt(1) is PackageAction1;
+            var hasAction2 = actions.ElementAt(0) is PackageAction2 || actions.ElementAt(1) is PackageAction2;
             Assert.IsTrue(hasAction1);
             Assert.IsTrue(hasAction2);
         }

src/Umbraco.Tests/Composing/TypeFinderTests.cs

@@ -93,7 +93,7 @@ namespace Umbraco.Tests.Composing
             Assert.AreEqual(22, typesFound.Count()); // + classes in Umbraco.Web are marked with [Tree]
         }
 
-        private static ProfilingLogger GetTestProfilingLogger()
+        private static IProfilingLogger GetTestProfilingLogger()
         {
             var logger = new DebugDiagnosticsLogger();
             var profiler = new TestProfiler();

src/Umbraco.Tests/Composing/TypeLoaderTests.cs

@@ -9,6 +9,7 @@ using umbraco;
 using Umbraco.Core;
 using Umbraco.Core.Cache;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Configuration;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.PropertyEditors;
@@ -27,7 +28,7 @@ namespace Umbraco.Tests.Composing
         public void Initialize()
         {
             // this ensures it's reset
-            _typeLoader = new TypeLoader(NullCacheProvider.Instance, SettingsForTests.GenerateMockGlobalSettings(), new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>()));
+            _typeLoader = new TypeLoader(NullCacheProvider.Instance, LocalTempStorage.Default, new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>()));
 
             foreach (var file in Directory.GetFiles(IOHelper.MapPath("~/App_Data/TEMP/TypesCache")))
                 File.Delete(file);

src/Umbraco.Tests/Configurations/GlobalSettingsTests.cs

@@ -2,6 +2,7 @@
 using System.Web.Routing;
 using Moq;
 using NUnit.Framework;
+using Umbraco.Core.Composing;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.IO;
 using Umbraco.Tests.TestHelpers;
@@ -50,7 +51,7 @@ namespace Umbraco.Tests.Configurations
             SettingsForTests.ConfigureSettings(globalSettingsMock.Object);
 
             SystemDirectories.Root = rootPath;
-            Assert.AreEqual(outcome, UmbracoConfig.For.GlobalSettings().GetUmbracoMvcArea());
+            Assert.AreEqual(outcome, Current.Config.Global().GetUmbracoMvcArea());
         }
         
         [TestCase("/umbraco/editContent.aspx")]

src/Umbraco.Tests/CoreThings/TryConvertToTests.cs

@@ -3,7 +3,6 @@ using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Core.Strings;
 using Umbraco.Tests.TestHelpers;
-using Umbraco.Core.Composing;
 using Umbraco.Tests.Testing;
 
 namespace Umbraco.Tests.CoreThings
@@ -18,7 +17,7 @@ namespace Umbraco.Tests.CoreThings
             var settings = SettingsForTests.GetDefaultUmbracoSettings();
 
             // fixme - base should do it!
-            Container.RegisterSingleton<IShortStringHelper>(_ => new DefaultShortStringHelper(settings));
+            Composition.RegisterUnique<IShortStringHelper>(_ => new DefaultShortStringHelper(settings));
         }
 
         [Test]

src/Umbraco.Tests/CoreThings/UdiTests.cs

@@ -2,13 +2,13 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-using LightInject;
 using Moq;
 using Newtonsoft.Json;
 using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Core.Cache;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Configuration;
 using Umbraco.Core.Deploy;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Serialization;
@@ -23,11 +23,11 @@ namespace Umbraco.Tests.CoreThings
         public void SetUp()
         {
             // fixme - bad in a unit test - but Udi has a static ctor that wants it?!
-            var container = new Mock<IServiceContainer>();
+            var container = new Mock<IFactory>();
             var globalSettings = SettingsForTests.GenerateMockGlobalSettings();
-            container.Setup(x => x.GetInstance(typeof (TypeLoader))).Returns(
-                new TypeLoader(NullCacheProvider.Instance, globalSettings, new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>())));
-            Current.Container = container.Object;
+            container.Setup(x => x.GetInstance(typeof(TypeLoader))).Returns(
+                new TypeLoader(NullCacheProvider.Instance, LocalTempStorage.Default, new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>())));
+            Current.Factory = container.Object;
 
             Udi.ResetUdiTypes();
         }

src/Umbraco.Tests/FrontEnd/UmbracoHelperTests.cs

@@ -1,13 +1,13 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using LightInject;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Core.Cache;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Web;
 
@@ -407,19 +407,19 @@ namespace Umbraco.Tests.FrontEnd
         private void SetUpDependencyContainer()
         {
             // fixme - bad in a unit test - but Udi has a static ctor that wants it?!
-            var container = new Mock<IServiceContainer>();
+            var container = new Mock<IFactory>();
             var globalSettings = SettingsForTests.GenerateMockGlobalSettings();
 
             container
                 .Setup(x => x.GetInstance(typeof(TypeLoader)))
                 .Returns(new TypeLoader(
                     NullCacheProvider.Instance,
-                    globalSettings,
+                    LocalTempStorage.Default,
                     new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>())
                     )
                 );
 
-            Current.Container = container.Object;
+            Current.Factory = container.Object;
         }
     }
 }

src/Umbraco.Tests/IO/FileSystemsTests.cs

@@ -1,16 +1,18 @@
 using System;
 using System.IO;
 using System.Text;
-using LightInject;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
+using Umbraco.Core.Components;
 using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Composing.Composers;
 using Umbraco.Core.IO;
 using Umbraco.Core.IO.MediaPathSchemes;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Services;
+using Umbraco.Tests.Components;
 using Umbraco.Tests.TestHelpers;
 
 namespace Umbraco.Tests.IO
@@ -18,7 +20,8 @@ namespace Umbraco.Tests.IO
     [TestFixture]
     public class FileSystemsTests
     {
-        private ServiceContainer _container;
+        private IRegister _register;
+        private IFactory _factory;
 
         [SetUp]
         public void Setup()
@@ -27,13 +30,18 @@ namespace Umbraco.Tests.IO
             var config = SettingsForTests.GetDefaultUmbracoSettings();
             SettingsForTests.ConfigureSettings(config);
 
-            _container = new ServiceContainer();
-            _container.ConfigureUmbracoCore();
-            _container.Register(_ => Mock.Of<ILogger>());
-            _container.Register<FileSystems>();
-            _container.Register(_ => Mock.Of<IDataTypeService>());
-            _container.Register(_ => Mock.Of<IContentSection>());
-            _container.RegisterSingleton<IMediaPathScheme, OriginalMediaPathScheme>();
+            _register = RegisterFactory.Create();
+
+            var composition = new Composition(_register, new TypeLoader(), Mock.Of<IProfilingLogger>(), ComponentTests.MockRuntimeState(RuntimeLevel.Run));
+
+            composition.Register(_ => Mock.Of<ILogger>());
+            composition.Register(_ => Mock.Of<IDataTypeService>());
+            composition.Register(_ => Mock.Of<IContentSection>());
+            composition.RegisterUnique<IMediaPathScheme, OriginalMediaPathScheme>();
+
+            composition.ComposeFileSystems();
+
+            _factory = composition.CreateFactory();
 
             // make sure we start clean
             // because some tests will create corrupt or weird filesystems
@@ -47,31 +55,37 @@ namespace Umbraco.Tests.IO
             FileSystems.Reset();
 
             Current.Reset();
-            _container.Dispose();
+            _register.DisposeIfDisposable();
         }
 
-        private FileSystems FileSystems => _container.GetInstance<FileSystems>();
+        private FileSystems FileSystems => _factory.GetInstance<FileSystems>();
 
         [Test]
-        public void Can_Get_Base_File_System()
+        public void Can_Get_MediaFileSystem()
         {
-            var fileSystem = FileSystems.GetUnderlyingFileSystemProvider("media");
-
+            var fileSystem = _factory.GetInstance<IMediaFileSystem>();
             Assert.NotNull(fileSystem);
         }
 
         [Test]
-        public void Can_Get_Typed_File_System()
+        public void Can_Get_IMediaFileSystem()
         {
-            var fileSystem = FileSystems.GetFileSystemProvider<MediaFileSystem>();
-
+            var fileSystem = _factory.GetInstance<IMediaFileSystem>();
             Assert.NotNull(fileSystem);
         }
 
         [Test]
-        public void Media_Fs_Safe_Delete()
+        public void IMediaFileSystem_Is_Singleton()
         {
-            var fs = FileSystems.GetFileSystemProvider<MediaFileSystem>();
+            var fileSystem1 = _factory.GetInstance<IMediaFileSystem>();
+            var fileSystem2 = _factory.GetInstance<IMediaFileSystem>();
+            Assert.AreSame(fileSystem1, fileSystem2);
+        }
+
+        [Test]
+        public void Can_Delete_MediaFiles()
+        {
+            var fs = _factory.GetInstance<IMediaFileSystem>();
             var ms = new MemoryStream(Encoding.UTF8.GetBytes("test"));
             var virtPath = fs.GetMediaPath("file.txt", Guid.NewGuid(), Guid.NewGuid());
             fs.AddFile(virtPath, ms);
@@ -93,52 +107,42 @@ namespace Umbraco.Tests.IO
             Assert.IsTrue(Directory.Exists(physPath));
         }
 
-        public void Singleton_Typed_File_System()
-        {
-            var fs1 = FileSystems.GetFileSystemProvider<MediaFileSystem>();
-            var fs2 = FileSystems.GetFileSystemProvider<MediaFileSystem>();
 
-            Assert.AreSame(fs1, fs2);
+        // fixme - don't make sense anymore
+        /*
+        [Test]
+        public void Cannot_Get_InvalidFileSystem()
+        {
+            // throws because InvalidTypedFileSystem does not have the proper attribute with an alias
+            Assert.Throws<InvalidOperationException>(() => FileSystems.GetFileSystem<InvalidFileSystem>());
         }
 
         [Test]
-        public void Exception_Thrown_On_Invalid_Typed_File_System()
-        {
-            Assert.Throws<InvalidOperationException>(() => FileSystems.GetFileSystemProvider<InvalidTypedFileSystem>());
-        }
-
-        [Test]
-        public void Exception_Thrown_On_NonConfigured_Typed_File_System()
+        public void Cannot_Get_NonConfiguredFileSystem()
         {
             // note: we need to reset the manager between tests else the Accept_Fallback test would corrupt that one
-            Assert.Throws<ArgumentException>(() => FileSystems.GetFileSystemProvider<NonConfiguredTypeFileSystem>());
+            // throws because NonConfiguredFileSystem has the proper attribute with an alias,
+            // but then the container cannot find an IFileSystem implementation for that alias
+            Assert.Throws<InvalidOperationException>(() => FileSystems.GetFileSystem<NonConfiguredFileSystem>());
+
+            // all we'd need to pass is to register something like:
+            //_container.Register<IFileSystem>("noconfig", factory => new PhysicalFileSystem("~/foo"));
         }
 
-        [Test]
-        public void Accept_Fallback_On_NonConfigured_Typed_File_System()
+        internal class InvalidFileSystem : FileSystemWrapper
         {
-            var fs = FileSystems.GetFileSystemProvider<NonConfiguredTypeFileSystem>(() => new PhysicalFileSystem("~/App_Data/foo"));
-
-            Assert.NotNull(fs);
-        }
-
-        /// <summary>
-        /// Used in unit tests, for a typed file system we need to inherit from FileSystemWrapper and they MUST have a ctor
-        /// that only accepts a base IFileSystem object
-        /// </summary>
-        internal class InvalidTypedFileSystem : FileSystemWrapper
-        {
-            public InvalidTypedFileSystem(IFileSystem wrapped, string invalidParam)
-                : base(wrapped)
+            public InvalidFileSystem(IFileSystem innerFileSystem)
+                : base(innerFileSystem)
             { }
         }
 
-        [FileSystemProvider("noconfig")]
-        internal class NonConfiguredTypeFileSystem : FileSystemWrapper
+        [InnerFileSystem("noconfig")]
+        internal class NonConfiguredFileSystem : FileSystemWrapper
         {
-            public NonConfiguredTypeFileSystem(IFileSystem wrapped)
-                : base(wrapped)
+            public NonConfiguredFileSystem(IFileSystem innerFileSystem)
+                : base(innerFileSystem)
             { }
         }
+        */
     }
 }

src/Umbraco.Tests/IO/ShadowFileSystemTests.cs

@@ -1,10 +1,12 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
+using Umbraco.Core.Composing;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Scoping;
@@ -25,7 +27,7 @@ namespace Umbraco.Tests.IO
         {
             SafeCallContext.Clear();
             ClearFiles();
-            ShadowFileSystems.ResetId();
+            FileSystems.ResetShadowId();
         }
 
         [TearDown]
@@ -33,13 +35,13 @@ namespace Umbraco.Tests.IO
         {
             SafeCallContext.Clear();
             ClearFiles();
-            ShadowFileSystems.ResetId();
+            FileSystems.ResetShadowId();
         }
 
         private static void ClearFiles()
         {
             TestHelper.DeleteDirectory(IOHelper.MapPath("FileSysTests"));
-            TestHelper.DeleteDirectory(IOHelper.MapPath("App_Data"));
+            TestHelper.DeleteDirectory(IOHelper.MapPath("App_Data/TEMP/ShadowFs"));
         }
 
         private static string NormPath(string path)
@@ -373,74 +375,92 @@ namespace Umbraco.Tests.IO
             Assert.IsFalse(File.Exists(path + "/ShadowTests/sub/sub/f2.txt"));
         }
 
+        class FS : FileSystemWrapper
+        {
+            public FS(IFileSystem innerFileSystem)
+                : base(innerFileSystem)
+            { }
+        }
+
         [Test]
         public void ShadowScopeComplete()
         {
             var logger = Mock.Of<ILogger>();
 
             var path = IOHelper.MapPath("FileSysTests");
-            var appdata = IOHelper.MapPath("App_Data");
+            var shadowfs = IOHelper.MapPath("App_Data/TEMP/ShadowFs");
             Directory.CreateDirectory(path);
-            Directory.CreateDirectory(appdata);
+            Directory.CreateDirectory(shadowfs);
 
             var scopedFileSystems = false;
 
-            var fs = new PhysicalFileSystem(path, "ignore");
-            var sw = new ShadowWrapper(fs, "shadow", () => scopedFileSystems);
-            var swa = new[] { sw };
+            var phy = new PhysicalFileSystem(path, "ignore");
+
+            var container = Mock.Of<IFactory>();
+            var fileSystems = new FileSystems(container, logger) { IsScoped = () => scopedFileSystems };
+            var fs = fileSystems.GetFileSystem<FS>(phy);
+            var sw = (ShadowWrapper) fs.InnerFileSystem;
 
             using (var ms = new MemoryStream(Encoding.UTF8.GetBytes("foo")))
                 sw.AddFile("sub/f1.txt", ms);
-            Assert.IsTrue(fs.FileExists("sub/f1.txt"));
+            Assert.IsTrue(phy.FileExists("sub/f1.txt"));
 
             Guid id;
 
             // explicit shadow without scope does not work
             sw.Shadow(id = Guid.NewGuid());
-            Assert.IsTrue(Directory.Exists(appdata + "/TEMP/ShadowFs/" + id));
+            Assert.IsTrue(Directory.Exists(shadowfs + "/" + id));
             using (var ms = new MemoryStream(Encoding.UTF8.GetBytes("foo")))
                 sw.AddFile("sub/f2.txt", ms);
-            Assert.IsTrue(fs.FileExists("sub/f2.txt"));
+            Assert.IsTrue(phy.FileExists("sub/f2.txt"));
             sw.UnShadow(true);
-            Assert.IsTrue(fs.FileExists("sub/f2.txt"));
-            Assert.IsFalse(Directory.Exists(appdata + "/TEMP/ShadowFs/" + id));
+            Assert.IsTrue(phy.FileExists("sub/f2.txt"));
+            Assert.IsFalse(Directory.Exists(shadowfs + "/" + id));
 
             // shadow with scope but no complete does not complete
             scopedFileSystems = true; // pretend we have a scope
-            var scope = new ShadowFileSystems(id = Guid.NewGuid(), swa, logger);
-            Assert.IsTrue(Directory.Exists(appdata + "/TEMP/ShadowFs/" + id));
+            var scope = new ShadowFileSystems(fileSystems, id = Guid.NewGuid());
+            Assert.IsTrue(Directory.Exists(shadowfs + "/" + id));
             using (var ms = new MemoryStream(Encoding.UTF8.GetBytes("foo")))
                 sw.AddFile("sub/f3.txt", ms);
-            Assert.IsFalse(fs.FileExists("sub/f3.txt"));
-            Assert.AreEqual(1, Directory.GetDirectories(appdata + "/TEMP/ShadowFs").Length);
+            Assert.IsFalse(phy.FileExists("sub/f3.txt"));
+            var dirs = Directory.GetDirectories(shadowfs);
+            Assert.AreEqual(1, dirs.Length);
+            Assert.AreEqual((shadowfs + "/" + id).Replace('\\', '/'), dirs[0].Replace('\\', '/'));
+            dirs = Directory.GetDirectories(dirs[0]);
+            var typedDir = dirs.FirstOrDefault(x => x.Replace('\\', '/').EndsWith("/typed"));
+            Assert.IsNotNull(typedDir);
+            dirs = Directory.GetDirectories(typedDir);
+            var scopedDir = dirs.FirstOrDefault(x => x.Replace('\\', '/').EndsWith("/Umbraco.Tests.IO.ShadowFileSystemTests+FS")); // this is where files go
+            Assert.IsNotNull(scopedDir);
             scope.Dispose();
             scopedFileSystems = false;
-            Assert.IsFalse(fs.FileExists("sub/f3.txt"));
-            TestHelper.TryAssert(() => Assert.IsFalse(Directory.Exists(appdata + "/TEMP/ShadowFs/" + id)));
+            Assert.IsFalse(phy.FileExists("sub/f3.txt"));
+            TestHelper.TryAssert(() => Assert.IsFalse(Directory.Exists(shadowfs + "/" + id)));
 
             // shadow with scope and complete does complete
             scopedFileSystems = true; // pretend we have a scope
-            scope = new ShadowFileSystems(id = Guid.NewGuid(), swa, logger);
-            Assert.IsTrue(Directory.Exists(appdata + "/TEMP/ShadowFs/" + id));
+            scope = new ShadowFileSystems(fileSystems, id = Guid.NewGuid());
+            Assert.IsTrue(Directory.Exists(shadowfs + "/" + id));
             using (var ms = new MemoryStream(Encoding.UTF8.GetBytes("foo")))
                 sw.AddFile("sub/f4.txt", ms);
-            Assert.IsFalse(fs.FileExists("sub/f4.txt"));
-            Assert.AreEqual(1, Directory.GetDirectories(appdata + "/TEMP/ShadowFs").Length);
+            Assert.IsFalse(phy.FileExists("sub/f4.txt"));
+            Assert.AreEqual(1, Directory.GetDirectories(shadowfs).Length);
             scope.Complete();
             scope.Dispose();
             scopedFileSystems = false;
-            TestHelper.TryAssert(() => Assert.AreEqual(0, Directory.GetDirectories(appdata + "/TEMP/ShadowFs").Length));
-            Assert.IsTrue(fs.FileExists("sub/f4.txt"));
-            Assert.IsFalse(Directory.Exists(appdata + "/TEMP/ShadowFs/" + id));
+            TestHelper.TryAssert(() => Assert.AreEqual(0, Directory.GetDirectories(shadowfs).Length));
+            Assert.IsTrue(phy.FileExists("sub/f4.txt"));
+            Assert.IsFalse(Directory.Exists(shadowfs + "/" + id));
 
             // test scope for "another thread"
 
             scopedFileSystems = true; // pretend we have a scope
-            scope = new ShadowFileSystems(id = Guid.NewGuid(), swa, logger);
-            Assert.IsTrue(Directory.Exists(appdata + "/TEMP/ShadowFs/" + id));
+            scope = new ShadowFileSystems(fileSystems, id = Guid.NewGuid());
+            Assert.IsTrue(Directory.Exists(shadowfs + "/" + id));
             using (var ms = new MemoryStream(Encoding.UTF8.GetBytes("foo")))
                 sw.AddFile("sub/f5.txt", ms);
-            Assert.IsFalse(fs.FileExists("sub/f5.txt"));
+            Assert.IsFalse(phy.FileExists("sub/f5.txt"));
 
             // pretend we're another thread w/out scope
             scopedFileSystems = false;
@@ -448,12 +468,12 @@ namespace Umbraco.Tests.IO
                 sw.AddFile("sub/f6.txt", ms);
             scopedFileSystems = true; // pretend we have a scope
 
-            Assert.IsTrue(fs.FileExists("sub/f6.txt")); // other thread has written out to fs
+            Assert.IsTrue(phy.FileExists("sub/f6.txt")); // other thread has written out to fs
             scope.Complete();
             scope.Dispose();
             scopedFileSystems = false;
-            Assert.IsTrue(fs.FileExists("sub/f5.txt"));
-            Assert.IsFalse(Directory.Exists(appdata + "/TEMP/ShadowFs/" + id));
+            Assert.IsTrue(phy.FileExists("sub/f5.txt"));
+            Assert.IsFalse(Directory.Exists(shadowfs + "/" + id));
         }
 
         [Test]
@@ -462,27 +482,30 @@ namespace Umbraco.Tests.IO
             var logger = Mock.Of<ILogger>();
 
             var path = IOHelper.MapPath("FileSysTests");
-            var appdata = IOHelper.MapPath("App_Data");
+            var shadowfs = IOHelper.MapPath("App_Data/TEMP/ShadowFs");
             Directory.CreateDirectory(path);
 
             var scopedFileSystems = false;
 
-            var fs = new PhysicalFileSystem(path, "ignore");
-            var sw = new ShadowWrapper(fs, "shadow", () => scopedFileSystems);
-            var swa = new[] { sw };
+            var phy = new PhysicalFileSystem(path, "ignore");
+
+            var container = Mock.Of<IFactory>();
+            var fileSystems = new FileSystems(container, logger) { IsScoped = () => scopedFileSystems };
+            var fs = fileSystems.GetFileSystem<FS>( phy);
+            var sw = (ShadowWrapper) fs.InnerFileSystem;
 
             using (var ms = new MemoryStream(Encoding.UTF8.GetBytes("foo")))
                 sw.AddFile("sub/f1.txt", ms);
-            Assert.IsTrue(fs.FileExists("sub/f1.txt"));
+            Assert.IsTrue(phy.FileExists("sub/f1.txt"));
 
             Guid id;
 
             scopedFileSystems = true; // pretend we have a scope
-            var scope = new ShadowFileSystems(id = Guid.NewGuid(), swa, logger);
-            Assert.IsTrue(Directory.Exists(appdata + "/TEMP/ShadowFs/" + id));
+            var scope = new ShadowFileSystems(fileSystems, id = Guid.NewGuid());
+            Assert.IsTrue(Directory.Exists(shadowfs + "/" + id));
             using (var ms = new MemoryStream(Encoding.UTF8.GetBytes("foo")))
                 sw.AddFile("sub/f2.txt", ms);
-            Assert.IsFalse(fs.FileExists("sub/f2.txt"));
+            Assert.IsFalse(phy.FileExists("sub/f2.txt"));
 
             // pretend we're another thread w/out scope
             scopedFileSystems = false;
@@ -490,15 +513,15 @@ namespace Umbraco.Tests.IO
                 sw.AddFile("sub/f2.txt", ms);
             scopedFileSystems = true; // pretend we have a scope
 
-            Assert.IsTrue(fs.FileExists("sub/f2.txt")); // other thread has written out to fs
+            Assert.IsTrue(phy.FileExists("sub/f2.txt")); // other thread has written out to fs
             scope.Complete();
             scope.Dispose();
             scopedFileSystems = false;
-            Assert.IsTrue(fs.FileExists("sub/f2.txt"));
-            TestHelper.TryAssert(() => Assert.IsFalse(Directory.Exists(appdata + "/TEMP/ShadowFs/" + id)));
+            Assert.IsTrue(phy.FileExists("sub/f2.txt"));
+            TestHelper.TryAssert(() => Assert.IsFalse(Directory.Exists(shadowfs + "/" + id)));
 
             string text;
-            using (var s = fs.OpenFile("sub/f2.txt"))
+            using (var s = phy.OpenFile("sub/f2.txt"))
             using (var r = new StreamReader(s))
                 text = r.ReadToEnd();
 
@@ -512,27 +535,30 @@ namespace Umbraco.Tests.IO
             var logger = Mock.Of<ILogger>();
 
             var path = IOHelper.MapPath("FileSysTests");
-            var appdata = IOHelper.MapPath("App_Data");
+            var shadowfs = IOHelper.MapPath("App_Data/TEMP/ShadowFs");
             Directory.CreateDirectory(path);
 
             var scopedFileSystems = false;
 
-            var fs = new PhysicalFileSystem(path, "ignore");
-            var sw = new ShadowWrapper(fs, "shadow", () => scopedFileSystems);
-            var swa = new[] { sw };
+            var phy = new PhysicalFileSystem(path, "ignore");
+
+            var container = Mock.Of<IFactory>();
+            var fileSystems = new FileSystems(container, logger) { IsScoped = () => scopedFileSystems };
+            var fs = fileSystems.GetFileSystem<FS>( phy);
+            var sw = (ShadowWrapper)fs.InnerFileSystem;
 
             using (var ms = new MemoryStream(Encoding.UTF8.GetBytes("foo")))
                 sw.AddFile("sub/f1.txt", ms);
-            Assert.IsTrue(fs.FileExists("sub/f1.txt"));
+            Assert.IsTrue(phy.FileExists("sub/f1.txt"));
 
             Guid id;
 
             scopedFileSystems = true; // pretend we have a scope
-            var scope = new ShadowFileSystems(id = Guid.NewGuid(), swa, logger);
-            Assert.IsTrue(Directory.Exists(appdata + "/TEMP/ShadowFs/" + id));
+            var scope = new ShadowFileSystems(fileSystems, id = Guid.NewGuid());
+            Assert.IsTrue(Directory.Exists(shadowfs + "/" + id));
             using (var ms = new MemoryStream(Encoding.UTF8.GetBytes("foo")))
                 sw.AddFile("sub/f2.txt", ms);
-            Assert.IsFalse(fs.FileExists("sub/f2.txt"));
+            Assert.IsFalse(phy.FileExists("sub/f2.txt"));
 
             // pretend we're another thread w/out scope
             scopedFileSystems = false;
@@ -540,11 +566,11 @@ namespace Umbraco.Tests.IO
                 sw.AddFile("sub/f2.txt/f2.txt", ms);
             scopedFileSystems = true; // pretend we have a scope
 
-            Assert.IsTrue(fs.FileExists("sub/f2.txt/f2.txt")); // other thread has written out to fs
+            Assert.IsTrue(phy.FileExists("sub/f2.txt/f2.txt")); // other thread has written out to fs
 
             using (var ms = new MemoryStream(Encoding.UTF8.GetBytes("foo")))
                 sw.AddFile("sub/f3.txt", ms);
-            Assert.IsFalse(fs.FileExists("sub/f3.txt"));
+            Assert.IsFalse(phy.FileExists("sub/f3.txt"));
 
             scope.Complete();
 
@@ -570,7 +596,7 @@ namespace Umbraco.Tests.IO
             }
 
             // still, the rest of the changes has been applied ok
-            Assert.IsTrue(fs.FileExists("sub/f3.txt"));
+            Assert.IsTrue(phy.FileExists("sub/f3.txt"));
         }
 
         [Test]

src/Umbraco.Tests/Integration/ContentEventsTests.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using LightInject;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
@@ -20,6 +19,7 @@ using static Umbraco.Tests.Cache.DistributedCache.DistributedCacheTests;
 namespace Umbraco.Tests.Integration
 {
     [TestFixture]
+    [Category("Slow")]
     [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
     public class ContentEventsTests : TestWithSomeContentBase
     {
@@ -50,10 +50,10 @@ namespace Umbraco.Tests.Integration
         {
             base.Compose();
 
-            Container.Register<IServerRegistrar>(_ => new TestServerRegistrar()); // localhost-only
-            Container.Register<IServerMessenger, LocalServerMessenger>(new PerContainerLifetime());
+            Composition.Register<IServerRegistrar>(_ => new TestServerRegistrar()); // localhost-only
+            Composition.RegisterUnique<IServerMessenger, LocalServerMessenger>();
 
-            Container.RegisterCollectionBuilder<CacheRefresherCollectionBuilder>()
+            Composition.WithCollectionBuilder<CacheRefresherCollectionBuilder>()
                 .Add<ContentTypeCacheRefresher>()
                 .Add<ContentCacheRefresher>()
                 .Add<MacroCacheRefresher>();

src/Umbraco.Tests/Issues/U9560.cs

@@ -3,7 +3,8 @@ using NUnit.Framework;
 using Umbraco.Core.Models;
 using Umbraco.Core.Persistence;
 using Umbraco.Tests.Testing;
-using LightInject;
+using Umbraco.Core;
+using Umbraco.Core.Composing;
 using Umbraco.Tests.TestHelpers;
 
 namespace Umbraco.Tests.Issues
@@ -26,7 +27,7 @@ namespace Umbraco.Tests.Issues
             var aliasName = string.Empty;
 
             // read fields, same as what we do with PetaPoco Fetch<dynamic>
-            using (var db = Container.GetInstance<IUmbracoDatabaseFactory>().CreateDatabase())
+            using (var db = Factory.GetInstance<IUmbracoDatabaseFactory>().CreateDatabase())
             {
                 db.OpenSharedConnection();
                 try
@@ -54,7 +55,7 @@ namespace Umbraco.Tests.Issues
             Assert.AreEqual("Alias", aliasName);
 
             // try differently
-            using (var db = Container.GetInstance<IUmbracoDatabaseFactory>().CreateDatabase())
+            using (var db = Factory.GetInstance<IUmbracoDatabaseFactory>().CreateDatabase())
             {
                 db.OpenSharedConnection();
                 try

src/Umbraco.Tests/Macros/MacroTests.cs

@@ -4,6 +4,7 @@ using System.Web.UI.WebControls;
 using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Core.Cache;
+using Umbraco.Core.Composing;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Models;
 using Umbraco.Tests.TestHelpers;
@@ -26,7 +27,7 @@ namespace Umbraco.Tests.Macros
                 new IsolatedRuntimeCache(type => new ObjectCacheRuntimeCacheProvider()));
             //Current.ApplicationContext = new ApplicationContext(cacheHelper, new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>()));
 
-            UmbracoConfig.For.SetUmbracoSettings(SettingsForTests.GetDefaultUmbracoSettings());
+            Current.Config.SetUmbracoConfig(SettingsForTests.GetDefaultUmbracoSettings());
         }
 
         [TestCase("123", "IntProp", typeof(int))]

src/Umbraco.Tests/Manifest/ManifestParserTests.cs

@@ -2,7 +2,6 @@
 using System.Linq;
 using Moq;
 using System.Text;
-using LightInject;
 using NUnit.Framework;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
@@ -14,27 +13,25 @@ using Umbraco.Core.Manifest;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.PropertyEditors.Validators;
 using Umbraco.Core.Services;
-using Umbraco.Web.ContentApps;
 
 namespace Umbraco.Tests.Manifest
 {
     [TestFixture]
     public class ManifestParserTests
     {
-
         private ManifestParser _parser;
 
         [SetUp]
         public void Setup()
         {
             Current.Reset();
-            var container = Mock.Of<IServiceContainer>();
-            Current.Container = container;
+            var factory = Mock.Of<IFactory>();
+            Current.Factory = factory;
 
-            var serviceContext = new ServiceContext(
+            var serviceContext = ServiceContext.CreatePartial(
                 localizedTextService: Mock.Of<ILocalizedTextService>());
 
-            Mock.Get(container)
+            Mock.Get(factory)
                 .Setup(x => x.GetInstance(It.IsAny<Type>()))
                 .Returns<Type>(x =>
                 {

src/Umbraco.Tests/Membership/MembershipProviderBaseTests.cs

@@ -3,17 +3,9 @@ using System.Collections.Specialized;
 using System.Configuration.Provider;
 using System.Security.Cryptography;
 using System.Web.Security;
-using LightInject;
 using Moq;
 using NUnit.Framework;
-using Umbraco.Core;
-using Umbraco.Core.Composing;
-using Umbraco.Core.IO;
-using Umbraco.Core.Logging;
-using Umbraco.Core.Persistence;
-using Umbraco.Core.Scoping;
 using Umbraco.Core.Security;
-using Umbraco.Tests.TestHelpers;
 using Umbraco.Tests.Testing;
 
 namespace Umbraco.Tests.Membership

src/Umbraco.Tests/Misc/ApplicationUrlHelperTests.cs

@@ -1,7 +1,4 @@
 using System;
-using System.Configuration;
-using System.Linq;
-using LightInject;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
@@ -11,8 +8,6 @@ using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Sync;
 using Umbraco.Tests.TestHelpers;
-using Umbraco.Tests.Cache.DistributedCache;
-using Umbraco.Tests.TestHelpers.Stubs;
 
 
 namespace Umbraco.Tests.Misc
@@ -32,7 +27,7 @@ namespace Umbraco.Tests.Misc
         [Test]
         public void NoApplicationUrlByDefault()
         {
-            var state = new RuntimeState(Mock.Of<ILogger>(), new Lazy<IServerRegistrar>(Mock.Of<IServerRegistrar>), new Lazy<MainDom>(Mock.Of<MainDom>), Mock.Of<IUmbracoSettingsSection>(), Mock.Of<IGlobalSettings>());
+            var state = new RuntimeState(Mock.Of<ILogger>(), Mock.Of<IUmbracoSettingsSection>(), Mock.Of<IGlobalSettings>(), new Lazy<IMainDom>(), new Lazy<IServerRegistrar>());
             Assert.IsNull(state.ApplicationUrl);
         }
 
@@ -51,10 +46,7 @@ namespace Umbraco.Tests.Misc
             var registrar = new Mock<IServerRegistrar>();
             registrar.Setup(x => x.GetCurrentServerUmbracoApplicationUrl()).Returns("http://server1.com/umbraco");
 
-            var state = new RuntimeState(
-                Mock.Of<ILogger>(),
-                new Lazy<IServerRegistrar>(() => registrar.Object),
-                new Lazy<MainDom>(Mock.Of<MainDom>), settings, globalConfig.Object);
+            var state = new RuntimeState(Mock.Of<ILogger>(), settings, globalConfig.Object, new Lazy<IMainDom>(), new Lazy<IServerRegistrar>(() => registrar.Object));
 
             state.EnsureApplicationUrl();
 
@@ -75,9 +67,9 @@ namespace Umbraco.Tests.Misc
 
             ApplicationUrlHelper.ApplicationUrlProvider = request => "http://server1.com/umbraco";
 
-            
 
-            var state = new RuntimeState(Mock.Of<ILogger>(), new Lazy<IServerRegistrar>(Mock.Of<IServerRegistrar>), new Lazy<MainDom>(Mock.Of<MainDom>), settings, globalConfig.Object);
+
+            var state = new RuntimeState(Mock.Of<ILogger>(), settings, globalConfig.Object, new Lazy<IMainDom>(), new Lazy<IServerRegistrar>(() => Mock.Of<IServerRegistrar>()));
 
             state.EnsureApplicationUrl();
 
@@ -101,7 +93,7 @@ namespace Umbraco.Tests.Misc
             // still NOT set
             Assert.IsNull(url);
         }
-        
+
         [Test]
         public void SetApplicationUrlFromStSettingsNoSsl()
         {
@@ -112,8 +104,8 @@ namespace Umbraco.Tests.Misc
             var globalConfig = Mock.Get(SettingsForTests.GenerateMockGlobalSettings());
             globalConfig.Setup(x => x.UseHttps).Returns(false);
 
-            
-            
+
+
             var url = ApplicationUrlHelper.TryGetApplicationUrl(settings, Mock.Of<ILogger>(), globalConfig.Object, Mock.Of<IServerRegistrar>());
 
             Assert.AreEqual("http://mycoolhost.com/umbraco", url);
@@ -129,8 +121,8 @@ namespace Umbraco.Tests.Misc
             var globalConfig = Mock.Get(SettingsForTests.GenerateMockGlobalSettings());
             globalConfig.Setup(x => x.UseHttps).Returns(true);
 
-            
-            
+
+
             var url = ApplicationUrlHelper.TryGetApplicationUrl(settings, Mock.Of<ILogger>(), globalConfig.Object, Mock.Of<IServerRegistrar>());
 
             Assert.AreEqual("https://mycoolhost.com/umbraco", url);
@@ -146,13 +138,11 @@ namespace Umbraco.Tests.Misc
             var globalConfig = Mock.Get(SettingsForTests.GenerateMockGlobalSettings());
             globalConfig.Setup(x => x.UseHttps).Returns(true);
 
-            
+
 
             var url = ApplicationUrlHelper.TryGetApplicationUrl(settings, Mock.Of<ILogger>(), globalConfig.Object, Mock.Of<IServerRegistrar>());
 
             Assert.AreEqual("httpx://whatever.com/umbraco", url);
         }
-
-        
     }
 }

src/Umbraco.Tests/Models/ContentTests.cs

@@ -5,9 +5,12 @@ using System.Globalization;
 using System.Linq;
 using System.Threading;
 using Moq;
+using Umbraco.Core;
 using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Core.Cache;
+using Umbraco.Core.Composing;
+using Umbraco.Core.Composing.Composers;
 using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
@@ -38,10 +41,11 @@ namespace Umbraco.Tests.Models
         {
             base.Compose();
 
-            Container.Register(_ => Mock.Of<ILogger>());
-            Container.Register<FileSystems>();
-            Container.Register(_ => Mock.Of<IDataTypeService>());
-            Container.Register(_ => Mock.Of<IContentSection>());
+            Composition.Register(_ => Mock.Of<ILogger>());
+            Composition.ComposeFileSystems();
+
+            Composition.Register(_ => Mock.Of<IDataTypeService>());
+            Composition.Register(_ => Mock.Of<IContentSection>());
         }
 
         [Test]
@@ -51,7 +55,7 @@ namespace Umbraco.Tests.Models
             var content = new Content("content", -1, contentType) { Id = 1, VersionId = 1 };
 
             const string langFr = "fr-FR";
-            
+
             contentType.Variations = ContentVariation.Culture;
 
             Assert.IsFalse(content.IsPropertyDirty("CultureInfos"));    //hasn't been changed
@@ -69,7 +73,7 @@ namespace Umbraco.Tests.Models
 
             Thread.Sleep(500);                                          //The "Date" wont be dirty if the test runs too fast since it will be the same date
             content.SetCultureName("name-fr", langFr);
-            Assert.IsTrue(frCultureName.IsPropertyDirty("Date"));       
+            Assert.IsTrue(frCultureName.IsPropertyDirty("Date"));
             Assert.IsTrue(content.IsPropertyDirty("CultureInfos"));     //it's true now since we've updated a name
         }
 
@@ -100,7 +104,7 @@ namespace Umbraco.Tests.Models
             Thread.Sleep(500);                                          //The "Date" wont be dirty if the test runs too fast since it will be the same date
             content.SetCultureName("name-fr", langFr);
             content.PublishCulture(langFr);                             //we've set the name, now we're publishing it
-            Assert.IsTrue(frCultureName.IsPropertyDirty("Date"));       
+            Assert.IsTrue(frCultureName.IsPropertyDirty("Date"));
             Assert.IsTrue(content.IsPropertyDirty("PublishCultureInfos"));     //it's true now since we've updated a name
         }
 
@@ -206,7 +210,7 @@ namespace Umbraco.Tests.Models
             Assert.AreNotSame(content.Properties, clone.Properties);
         }
 
-        private static ProfilingLogger GetTestProfilingLogger()
+        private static IProfilingLogger GetTestProfilingLogger()
         {
             var logger = new DebugDiagnosticsLogger();
             var profiler = new TestProfiler();
@@ -305,7 +309,7 @@ namespace Umbraco.Tests.Models
             content.UpdateDate = DateTime.Now;
             content.WriterId = 23;
 
-            
+
 
             // Act
             var clone = (Content)content.DeepClone();
@@ -402,7 +406,7 @@ namespace Umbraco.Tests.Models
             content.SetCultureName("Hello", "en-US");
             content.SetCultureName("World", "es-ES");
             content.PublishCulture("en-US");
-            
+
             var i = 200;
             foreach (var property in content.Properties)
             {
@@ -420,7 +424,7 @@ namespace Umbraco.Tests.Models
             {
                 Id = 88
             };
-            
+
             content.Trashed = true;
             content.UpdateDate = DateTime.Now;
             content.WriterId = 23;

src/Umbraco.Tests/Models/ContentTypeTests.cs

@@ -93,7 +93,7 @@ namespace Umbraco.Tests.Models
             }
         }
 
-        private static ProfilingLogger GetTestProfilingLogger()
+        private static IProfilingLogger GetTestProfilingLogger()
         {
             var logger = new DebugDiagnosticsLogger();
             var profiler = new TestProfiler();

src/Umbraco.Tests/Models/Mapping/AutoMapperTests.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using AutoMapper;
 using NUnit.Framework;
@@ -9,7 +8,6 @@ using Umbraco.Core.Manifest;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Tests.Testing;
-using LightInject;
 
 namespace Umbraco.Tests.Models.Mapping
 {
@@ -22,16 +20,16 @@ namespace Umbraco.Tests.Models.Mapping
             base.Compose();
 
             var manifestBuilder = new ManifestParser(
-                CacheHelper.CreateDisabledCacheHelper().RuntimeCache,
+                CacheHelper.Disabled.RuntimeCache,
                 new ManifestValueValidatorCollection(Enumerable.Empty<IManifestValueValidator>()),
-                Logger)
+                Composition.Logger)
             {
                 Path = TestHelper.CurrentAssemblyDirectory
             };
-            Container.Register(_ => manifestBuilder);
+            Composition.RegisterUnique(_ => manifestBuilder);
 
             Func<IEnumerable<Type>> typeListProducerList = Enumerable.Empty<Type>;
-            Container.GetInstance<DataEditorCollectionBuilder>()
+            Composition.WithCollectionBuilder<DataEditorCollectionBuilder>()
                 .Clear()
                 .Add(typeListProducerList);
         }
@@ -39,7 +37,7 @@ namespace Umbraco.Tests.Models.Mapping
         [Test]
         public void AssertConfigurationIsValid()
         {
-            var profiles = Container.GetAllInstances<Profile>().ToArray();
+            var profiles = Factory.GetAllInstances<Profile>().ToArray();
 
             var config = new MapperConfiguration(cfg =>
             {

src/Umbraco.Tests/Models/Mapping/ContentTypeModelMappingTests.cs

@@ -1,11 +1,9 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using AutoMapper;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
-using Umbraco.Core.Composing;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.PropertyEditors;
@@ -55,13 +53,13 @@ namespace Umbraco.Tests.Models.Mapping
             var dataEditors = new DataEditorCollection(editors);
             _editorsMock = new Mock<PropertyEditorCollection>(dataEditors);
             _editorsMock.Setup(x => x[It.IsAny<string>()]).Returns(editors[0]);
-            Container.RegisterSingleton(f => _editorsMock.Object);
+            Composition.RegisterUnique(f => _editorsMock.Object);
 
-            Container.RegisterSingleton(_ => _contentTypeService.Object);
-            Container.RegisterSingleton(_ => _contentService.Object);
-            Container.RegisterSingleton(_ => _dataTypeService.Object);
-            Container.RegisterSingleton(_ => _entityService.Object);
-            Container.RegisterSingleton(_ => _fileService.Object);
+            Composition.RegisterUnique(_ => _contentTypeService.Object);
+            Composition.RegisterUnique(_ => _contentService.Object);
+            Composition.RegisterUnique(_ => _dataTypeService.Object);
+            Composition.RegisterUnique(_ => _entityService.Object);
+            Composition.RegisterUnique(_ => _fileService.Object);
         }
 
         [Test]

src/Umbraco.Tests/Models/Mapping/ContentWebModelMappingTests.cs

@@ -12,7 +12,6 @@ using Umbraco.Core.PropertyEditors;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Tests.TestHelpers.Entities;
 using Umbraco.Web.Models.ContentEditing;
-using Umbraco.Core.Composing;
 using Umbraco.Tests.Testing;
 using Current = Umbraco.Web.Composing.Current;
 
@@ -26,7 +25,7 @@ namespace Umbraco.Tests.Models.Mapping
         {
             base.Compose();
 
-            Container.RegisterSingleton(f => Mock.Of<ICultureDictionaryFactory>());
+            Composition.RegisterUnique(f => Mock.Of<ICultureDictionaryFactory>());
         }
 
         [DataEditor("Test.Test", "Test", "~/Test.html")]
@@ -158,7 +157,7 @@ namespace Umbraco.Tests.Models.Mapping
                 AssertBasicProperty(invariantContent, p);
                 AssertDisplayProperty(invariantContent, p);
             }
-            
+
             Assert.AreEqual(content.PropertyGroups.Count(), invariantContent.Tabs.Count());
         }
 

src/Umbraco.Tests/Models/MediaXmlTest.cs

@@ -29,7 +29,12 @@ namespace Umbraco.Tests.Models
 
             // reference, so static ctor runs, so event handlers register
             // and then, this will reset the width, height... because the file does not exist, of course ;-(
-            var ignored = new FileUploadPropertyEditor(Mock.Of<ILogger>(), new MediaFileSystem(Mock.Of<IFileSystem>()), Mock.Of<IContentSection>());
+            var logger = Mock.Of<ILogger>();
+            var scheme = Mock.Of<IMediaPathScheme>();
+            var config = Mock.Of<IContentSection>();
+
+            var mediaFileSystem = new MediaFileSystem(Mock.Of<IFileSystem>(), config, scheme, logger);
+            var ignored = new FileUploadPropertyEditor(Mock.Of<ILogger>(), mediaFileSystem, config);
 
             var media = MockedMedia.CreateMediaImage(mediaType, -1);
             media.WriterId = -1; // else it's zero and that's not a user and it breaks the tests

src/Umbraco.Tests/Models/VariationTests.cs

@@ -1,5 +1,4 @@
 using System;
-using LightInject;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
@@ -27,8 +26,8 @@ namespace Umbraco.Tests.Models
             // need to be able to retrieve them all...
 
             Current.Reset();
-            var container = Mock.Of<IServiceContainer>();
-            Current.Container = container;
+            var factory = Mock.Of<IFactory>();
+            Current.Factory = factory;
 
             var dataEditors = new DataEditorCollection(new IDataEditor[]
             {
@@ -46,11 +45,11 @@ namespace Umbraco.Tests.Models
                 .Setup(x => x.GetDataType(It.IsAny<int>()))
                 .Returns<int>(x => dataType);
 
-            var serviceContext = new ServiceContext(
+            var serviceContext = ServiceContext.CreatePartial(
                 dataTypeService: dataTypeService,
                 localizedTextService: Mock.Of<ILocalizedTextService>());
 
-            Mock.Get(container)
+            Mock.Get(factory)
                 .Setup(x => x.GetInstance(It.IsAny<Type>()))
                 .Returns<Type>(x =>
                 {

src/Umbraco.Tests/Persistence/DatabaseContextTests.cs

@@ -14,6 +14,7 @@ using Umbraco.Core.Persistence.Mappers;
 using Umbraco.Core.Persistence.SqlSyntax;
 using Umbraco.Core.Services;
 using Umbraco.Tests.TestHelpers;
+using Umbraco.Web.Security;
 
 namespace Umbraco.Tests.Persistence
 {
@@ -33,7 +34,7 @@ namespace Umbraco.Tests.Persistence
             _sqlCeSyntaxProvider = new SqlCeSyntaxProvider();
             _sqlSyntaxProviders = new[] { (ISqlSyntaxProvider) _sqlCeSyntaxProvider };
             _logger = Mock.Of<ILogger>();
-            _databaseFactory = new UmbracoDatabaseFactory(_sqlSyntaxProviders, _logger, Mock.Of<IMapperCollection>());
+            _databaseFactory = new UmbracoDatabaseFactory(_logger, new Lazy<IMapperCollection>(() => Mock.Of<IMapperCollection>()));
         }
 
         [TearDown]
@@ -76,7 +77,7 @@ namespace Umbraco.Tests.Persistence
             }
 
             // re-create the database factory and database context with proper connection string
-            _databaseFactory = new UmbracoDatabaseFactory(connString, Constants.DbProviderNames.SqlCe, _sqlSyntaxProviders, _logger, Mock.Of<IMapperCollection>());
+            _databaseFactory = new UmbracoDatabaseFactory(connString, Constants.DbProviderNames.SqlCe, _logger, new Lazy<IMapperCollection>(() => Mock.Of<IMapperCollection>()));
 
             // create application context
             //var appCtx = new ApplicationContext(
@@ -88,9 +89,11 @@ namespace Umbraco.Tests.Persistence
             // 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");

src/Umbraco.Tests/Persistence/FaultHandling/ConnectionRetryTest.cs

@@ -19,8 +19,7 @@ namespace Umbraco.Tests.Persistence.FaultHandling
         {
             const string connectionString = @"server=.\SQLEXPRESS;database=EmptyForTest;user id=x;password=umbraco";
             const string providerName = Constants.DbProviderNames.SqlServer;
-            var sqlSyntax = new[] { new SqlServerSyntaxProvider(new Lazy<IScopeProvider>(() => null)) };
-            var factory = new UmbracoDatabaseFactory(connectionString, providerName, sqlSyntax, Mock.Of<ILogger>(), Mock.Of<IMapperCollection>());
+            var factory = new UmbracoDatabaseFactory(connectionString, providerName, Mock.Of<ILogger>(), new Lazy<IMapperCollection>(() => Mock.Of<IMapperCollection>()));
 
             using (var database = factory.CreateDatabase())
             {
@@ -34,8 +33,7 @@ namespace Umbraco.Tests.Persistence.FaultHandling
         {
             const string connectionString = @"server=.\SQLEXPRESS;database=EmptyForTest;user id=umbraco;password=umbraco";
             const string providerName = Constants.DbProviderNames.SqlServer;
-            var sqlSyntax = new[] { new SqlServerSyntaxProvider(new Lazy<IScopeProvider>(() => null)) };
-            var factory = new UmbracoDatabaseFactory(connectionString, providerName, sqlSyntax, Mock.Of<ILogger>(), Mock.Of<IMapperCollection>());
+            var factory = new UmbracoDatabaseFactory(connectionString, providerName, Mock.Of<ILogger>(), new Lazy<IMapperCollection>(() => Mock.Of<IMapperCollection>()));
 
             using (var database = factory.CreateDatabase())
             {

src/Umbraco.Tests/Persistence/Repositories/AuditRepositoryTest.cs

@@ -1,6 +1,5 @@
 using System.Linq;
 using NUnit.Framework;
-using Umbraco.Core.Composing;
 using Umbraco.Core.Models;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
@@ -26,7 +25,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var sp = TestObjects.GetScopeProvider(Logger);
             using (var scope = sp.CreateScope())
             {
-                var repo = new AuditRepository((IScopeAccessor) sp, CacheHelper, Logger);
+                var repo = new AuditRepository((IScopeAccessor) sp, Logger);
                 repo.Save(new AuditItem(-1, AuditType.System, -1, ObjectTypes.GetName(UmbracoObjectTypes.Document), "This is a System audit trail"));
 
                 var dtos = scope.Database.Fetch<LogDto>("WHERE id > -1");
@@ -42,7 +41,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var sp = TestObjects.GetScopeProvider(Logger);
             using (var scope = sp.CreateScope())
             {
-                var repo = new AuditRepository((IScopeAccessor) sp, CacheHelper, Logger);
+                var repo = new AuditRepository((IScopeAccessor) sp, Logger);
 
                 for (var i = 0; i < 100; i++)
                 {
@@ -55,7 +54,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             using (var scope = sp.CreateScope())
             {
-                var repo = new AuditRepository((IScopeAccessor) sp, CacheHelper, Logger);
+                var repo = new AuditRepository((IScopeAccessor) sp, Logger);
 
                 var page = repo.GetPagedResultsByQuery(sp.SqlContext.Query<IAuditItem>(), 0, 10, out var total, Direction.Descending, null, null);
 
@@ -70,7 +69,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var sp = TestObjects.GetScopeProvider(Logger);
             using (var scope = sp.CreateScope())
             {
-                var repo = new AuditRepository((IScopeAccessor)sp, CacheHelper, Logger);
+                var repo = new AuditRepository((IScopeAccessor)sp, Logger);
 
                 for (var i = 0; i < 100; i++)
                 {
@@ -83,7 +82,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             using (var scope = sp.CreateScope())
             {
-                var repo = new AuditRepository((IScopeAccessor)sp, CacheHelper, Logger);
+                var repo = new AuditRepository((IScopeAccessor)sp, Logger);
 
                 var query = sp.SqlContext.Query<IAuditItem>().Where(x => x.UserId == -1);
 
@@ -113,7 +112,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var sp = TestObjects.GetScopeProvider(Logger);
             using (var scope = sp.CreateScope())
             {
-                var repo = new AuditRepository((IScopeAccessor) sp, CacheHelper, Logger);
+                var repo = new AuditRepository((IScopeAccessor) sp, Logger);
 
                 for (var i = 0; i < 100; i++)
                 {
@@ -126,7 +125,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             using (var scope = sp.CreateScope())
             {
-                var repo = new AuditRepository((IScopeAccessor) sp, CacheHelper, Logger);
+                var repo = new AuditRepository((IScopeAccessor) sp, Logger);
 
                 var page = repo.GetPagedResultsByQuery(sp.SqlContext.Query<IAuditItem>(), 0, 9, out var total, Direction.Descending,
                         new[] {AuditType.Publish}, null)
@@ -144,7 +143,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var sp = TestObjects.GetScopeProvider(Logger);
             using (var scope = sp.CreateScope())
             {
-                var repo = new AuditRepository((IScopeAccessor) sp, CacheHelper, Logger);
+                var repo = new AuditRepository((IScopeAccessor) sp, Logger);
 
                 for (var i = 0; i < 100; i++)
                 {
@@ -157,7 +156,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             using (var scope = sp.CreateScope())
             {
-                var repo = new AuditRepository((IScopeAccessor) sp, CacheHelper, Logger);
+                var repo = new AuditRepository((IScopeAccessor) sp, Logger);
 
                 var page = repo.GetPagedResultsByQuery(sp.SqlContext.Query<IAuditItem>(), 0, 8, out var total, Direction.Descending,
                         null, sp.SqlContext.Query<IAuditItem>().Where(item => item.Comment == "Content created"))

src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs

@@ -35,8 +35,8 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private DocumentRepository CreateRepository(IScopeAccessor scopeAccessor, out ContentTypeRepository contentTypeRepository)
         {
-            var cacheHelper = CacheHelper.CreateDisabledCacheHelper();
-            var templateRepository = new TemplateRepository(scopeAccessor, cacheHelper, Logger, Mock.Of<ITemplatesSection>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>());
+            var cacheHelper = CacheHelper.Disabled;
+            var templateRepository = new TemplateRepository(scopeAccessor, cacheHelper, Logger, Mock.Of<ITemplatesSection>(), TestObjects.GetFileSystemsMock());
             var tagRepository = new TagRepository(scopeAccessor, cacheHelper, Logger);
             contentTypeRepository = new ContentTypeRepository(scopeAccessor, cacheHelper, Logger, templateRepository);
             var languageRepository = new LanguageRepository(scopeAccessor, cacheHelper, Logger);
@@ -46,20 +46,20 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private ContentTypeRepository CreateRepository(IScopeAccessor scopeAccessor)
         {
-            var templateRepository = new TemplateRepository(scopeAccessor, CacheHelper.CreateDisabledCacheHelper(), Logger, Mock.Of<ITemplatesSection>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>());
-            var contentTypeRepository = new ContentTypeRepository(scopeAccessor, CacheHelper.CreateDisabledCacheHelper(), Logger, templateRepository);
+            var templateRepository = new TemplateRepository(scopeAccessor, CacheHelper.Disabled, Logger, Mock.Of<ITemplatesSection>(), TestObjects.GetFileSystemsMock());
+            var contentTypeRepository = new ContentTypeRepository(scopeAccessor, CacheHelper.Disabled, Logger, templateRepository);
             return contentTypeRepository;
         }
 
         private MediaTypeRepository CreateMediaTypeRepository(IScopeAccessor scopeAccessor)
         {
-            var contentTypeRepository = new MediaTypeRepository(scopeAccessor, CacheHelper.CreateDisabledCacheHelper(), Logger);
+            var contentTypeRepository = new MediaTypeRepository(scopeAccessor, CacheHelper.Disabled, Logger);
             return contentTypeRepository;
         }
 
         private EntityContainerRepository CreateContainerRepository(IScopeAccessor scopeAccessor, Guid containerEntityType)
         {
-            return new EntityContainerRepository(scopeAccessor, CacheHelper.CreateDisabledCacheHelper(), Logger, containerEntityType);
+            return new EntityContainerRepository(scopeAccessor, CacheHelper.Disabled, Logger, containerEntityType);
         }
 
         //TODO Add test to verify SetDefaultTemplates updates both AllowedTemplates and DefaultTemplate(id).
@@ -71,7 +71,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var templateRepo = new TemplateRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Logger, Mock.Of<ITemplatesSection>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>());
+                var templateRepo = new TemplateRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger, Mock.Of<ITemplatesSection>(), TestObjects.GetFileSystemsMock());
                 var repository = CreateRepository((IScopeAccessor) provider);
                 var templates = new[]
                 {

src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs

@@ -6,7 +6,7 @@ using Umbraco.Core.Models;
 using Umbraco.Core.Persistence.Repositories;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Tests.Testing;
-using LightInject;
+using Umbraco.Core.Composing;
 using Umbraco.Core.Persistence.Repositories.Implement;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.Scoping;
@@ -20,12 +20,12 @@ namespace Umbraco.Tests.Persistence.Repositories
     {
         private IDataTypeRepository CreateRepository()
         {
-            return Container.GetInstance<IDataTypeRepository>();
+            return Factory.GetInstance<IDataTypeRepository>();
         }
 
         private EntityContainerRepository CreateContainerRepository(IScopeAccessor scopeAccessor)
         {
-            return new EntityContainerRepository(scopeAccessor, CacheHelper.CreateDisabledCacheHelper(), Logger, Constants.ObjectTypes.DataTypeContainer);
+            return new EntityContainerRepository(scopeAccessor, CacheHelper.Disabled, Logger, Constants.ObjectTypes.DataTypeContainer);
         }
 
         [Test]

src/Umbraco.Tests/Persistence/Repositories/DictionaryRepositoryTest.cs

@@ -6,8 +6,8 @@ using Umbraco.Core.Models;
 using Umbraco.Core.Persistence.Repositories;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Tests.Testing;
-using LightInject;
-using Umbraco.Core.Scoping;
+using Umbraco.Core;
+using Umbraco.Core.Composing;
 
 namespace Umbraco.Tests.Persistence.Repositories
 {
@@ -24,7 +24,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private IDictionaryRepository CreateRepository()
         {
-            return Container.GetInstance<IDictionaryRepository>();
+            return Factory.GetInstance<IDictionaryRepository>();
         }
 
         [Test]
@@ -230,7 +230,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var languageRepository = Container.GetInstance<ILanguageRepository>();
+                var languageRepository = Factory.GetInstance<ILanguageRepository>();
                 var repository = CreateRepository();
 
                 var language = languageRepository.Get(1);

src/Umbraco.Tests/Persistence/Repositories/DocumentRepositoryTest.cs

@@ -64,7 +64,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             cacheHelper = cacheHelper ?? CacheHelper;
 
-            templateRepository = new TemplateRepository(scopeAccessor, cacheHelper, Logger, Mock.Of<ITemplatesSection>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>());
+            templateRepository = new TemplateRepository(scopeAccessor, cacheHelper, Logger, Mock.Of<ITemplatesSection>(), TestObjects.GetFileSystemsMock());
             var tagRepository = new TagRepository(scopeAccessor, cacheHelper, Logger);
             contentTypeRepository = new ContentTypeRepository(scopeAccessor, cacheHelper, Logger, templateRepository);
             var languageRepository = new LanguageRepository(scopeAccessor, cacheHelper, Logger);
@@ -670,7 +670,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         [Test]
         public void AliasRegexTest()
         {
-            var regex = new SqlServerSyntaxProvider(new Lazy<IScopeProvider>(() => null)).AliasRegex;
+            var regex = new SqlServerSyntaxProvider().AliasRegex;
             Assert.AreEqual(@"(\[\w+]\.\[\w+])\s+AS\s+(\[\w+])", regex.ToString());
             const string sql = "SELECT [table].[column1] AS [alias1], [table].[column2] AS [alias2] FROM [table];";
             var matches = regex.Matches(sql);

src/Umbraco.Tests/Persistence/Repositories/DomainRepositoryTest.cs

@@ -22,12 +22,12 @@ namespace Umbraco.Tests.Persistence.Repositories
         private DomainRepository CreateRepository(IScopeProvider provider, out ContentTypeRepository contentTypeRepository, out DocumentRepository documentRepository, out LanguageRepository languageRepository)
         {
             var accessor = (IScopeAccessor) provider;
-            var templateRepository = new TemplateRepository(accessor, DisabledCache, Logger, Mock.Of<ITemplatesSection>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>());
-            var tagRepository = new TagRepository(accessor, DisabledCache, Logger);
-            contentTypeRepository = new ContentTypeRepository(accessor, DisabledCache, Logger, templateRepository);
-            languageRepository = new LanguageRepository(accessor, DisabledCache, Logger);
-            documentRepository = new DocumentRepository(accessor, DisabledCache, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, Mock.Of<IContentSection>());
-            var domainRepository = new DomainRepository(accessor, DisabledCache, Logger);
+            var templateRepository = new TemplateRepository(accessor, Core.Cache.CacheHelper.Disabled, Logger, Mock.Of<ITemplatesSection>(), TestObjects.GetFileSystemsMock());
+            var tagRepository = new TagRepository(accessor, Core.Cache.CacheHelper.Disabled, Logger);
+            contentTypeRepository = new ContentTypeRepository(accessor, Core.Cache.CacheHelper.Disabled, Logger, templateRepository);
+            languageRepository = new LanguageRepository(accessor, Core.Cache.CacheHelper.Disabled, Logger);
+            documentRepository = new DocumentRepository(accessor, Core.Cache.CacheHelper.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, Mock.Of<IContentSection>());
+            var domainRepository = new DomainRepository(accessor, Core.Cache.CacheHelper.Disabled, Logger);
             return domainRepository;
         }
 

src/Umbraco.Tests/Persistence/Repositories/LanguageRepositoryTest.cs

@@ -26,7 +26,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private LanguageRepository CreateRepository(IScopeProvider provider)
         {
-            return new LanguageRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+            return new LanguageRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
         }
 
         [Test]

src/Umbraco.Tests/Persistence/Repositories/MacroRepositoryTest.cs

@@ -35,7 +35,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 var macro = new Macro("test1", "Test", "~/views/macropartials/test.cshtml", MacroTypes.PartialView);
                 ;
@@ -52,7 +52,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 var macro = repository.Get(1);
                 macro.Alias = "test2";
@@ -69,7 +69,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 // Assert
                 Assert.That(repository, Is.Not.Null);
@@ -83,7 +83,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 // Act
                 var macro = repository.Get(1);
@@ -111,7 +111,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 // Act
                 var macros = repository.GetMany();
@@ -129,7 +129,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 // Act
                 var query = scope.SqlContext.Query<IMacro>().Where(x => x.Alias.ToUpper() == "TEST1");
@@ -147,7 +147,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 // Act
                 var query = scope.SqlContext.Query<IMacro>().Where(x => x.Name.StartsWith("Test"));
@@ -165,7 +165,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 // Act
                 var macro = new Macro("test", "Test", "~/views/macropartials/test.cshtml", MacroTypes.PartialView);
@@ -186,7 +186,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 // Act
                 var macro = repository.Get(2);
@@ -221,7 +221,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 // Act
                 var macro = repository.Get(3);
@@ -242,7 +242,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 // Act
                 var exists = repository.Exists(3);
@@ -261,7 +261,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 var macro = repository.Get(1);
                 macro.Properties.Add(new MacroProperty("new1", "New1", 3, "test"));
@@ -287,7 +287,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 var macro = new Macro("newmacro", "A new macro", "~/views/macropartials/test1.cshtml", MacroTypes.PartialView);
                 macro.Properties.Add(new MacroProperty("blah1", "New1", 4, "test.editor"));
@@ -312,7 +312,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 var macro = new Macro("newmacro", "A new macro", "~/views/macropartials/test1.cshtml", MacroTypes.PartialView);
                 macro.Properties.Add(new MacroProperty("blah1", "New1", 4, "test.editor"));
@@ -336,7 +336,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 var macro = new Macro("newmacro", "A new macro", "~/views/macropartials/test1.cshtml", MacroTypes.PartialView);
                 var prop1 = new MacroProperty("blah1", "New1", 4, "test.editor");
@@ -367,7 +367,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 var macro = repository.Get(1);
                 macro.Properties.Add(new MacroProperty("new1", "New1", 3, "test"));
@@ -394,7 +394,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 var macro = repository.Get(1);
                 macro.Properties.Add(new MacroProperty("new1", "New1", 3, "test"));
@@ -422,7 +422,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 repository.Save(new Macro("test1", "Test1", "~/views/macropartials/test1.cshtml", MacroTypes.PartialView));
                 repository.Save(new Macro("test2", "Test2", "~/views/macropartials/test2.cshtml", MacroTypes.PartialView));

src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs

@@ -2,6 +2,7 @@
 using System.Linq;
 using NUnit.Framework;
 using Umbraco.Core;
+using Umbraco.Core.Cache;
 using Umbraco.Core.Models;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.Dtos;
@@ -20,12 +21,12 @@ namespace Umbraco.Tests.Persistence.Repositories
     {
         private MediaTypeRepository CreateRepository(IScopeProvider provider)
         {
-            return new MediaTypeRepository((IScopeAccessor) provider, DisabledCache, Logger);
+            return new MediaTypeRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger);
         }
 
         private EntityContainerRepository CreateContainerRepository(IScopeProvider provider)
         {
-            return new EntityContainerRepository((IScopeAccessor) provider, DisabledCache, Logger, Constants.ObjectTypes.MediaTypeContainer);
+            return new EntityContainerRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger, Constants.ObjectTypes.MediaTypeContainer);
 
         }
 

src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs

@@ -6,6 +6,7 @@ using Moq;
 using NPoco;
 using NUnit.Framework;
 using Umbraco.Core;
+using Umbraco.Core.Cache;
 using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
@@ -28,10 +29,10 @@ namespace Umbraco.Tests.Persistence.Repositories
         private MemberRepository CreateRepository(IScopeProvider provider, out MemberTypeRepository memberTypeRepository, out MemberGroupRepository memberGroupRepository)
         {
             var accessor = (IScopeAccessor) provider;
-            memberTypeRepository = new MemberTypeRepository(accessor, DisabledCache, Logger);
-            memberGroupRepository = new MemberGroupRepository(accessor, DisabledCache, Logger);
-            var tagRepo = new TagRepository(accessor, DisabledCache, Logger);
-            var repository = new MemberRepository(accessor, DisabledCache, Logger, memberTypeRepository, memberGroupRepository, tagRepo, Mock.Of<ILanguageRepository>());
+            memberTypeRepository = new MemberTypeRepository(accessor, CacheHelper.Disabled, Logger);
+            memberGroupRepository = new MemberGroupRepository(accessor, CacheHelper.Disabled, Logger);
+            var tagRepo = new TagRepository(accessor, CacheHelper.Disabled, Logger);
+            var repository = new MemberRepository(accessor, CacheHelper.Disabled, Logger, memberTypeRepository, memberGroupRepository, tagRepo, Mock.Of<ILanguageRepository>());
             return repository;
         }
 

src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs

@@ -22,7 +22,7 @@ namespace Umbraco.Tests.Persistence.Repositories
     {
         private MemberTypeRepository CreateRepository(IScopeProvider provider)
         {
-            return new MemberTypeRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+            return new MemberTypeRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
         }
 
         [Test]

src/Umbraco.Tests/Persistence/Repositories/PartialViewRepositoryTests.cs

@@ -1,12 +1,10 @@
 using System.Linq;
+using Moq;
 using NUnit.Framework;
 using Umbraco.Core.IO;
 using Umbraco.Core.Models;
-using Umbraco.Core.Persistence.Repositories;
 using Umbraco.Core.PropertyEditors;
-using Umbraco.Core.Composing;
 using Umbraco.Core.Persistence.Repositories.Implement;
-using Umbraco.Core.Scoping;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Tests.Testing;
 
@@ -29,7 +27,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             base.Compose();
 
-            Container.RegisterSingleton(f => new DataEditorCollection(Enumerable.Empty<DataEditor>()));
+            Composition.RegisterUnique(f => new DataEditorCollection(Enumerable.Empty<DataEditor>()));
         }
 
         [Test]
@@ -37,10 +35,13 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             // unless noted otherwise, no changes / 7.2.8
 
+            var fileSystems = Mock.Of<IFileSystems>();
+            Mock.Get(fileSystems).Setup(x => x.PartialViewsFileSystem).Returns(_fileSystem);
+
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new PartialViewRepository(_fileSystem);
+                var repository = new PartialViewRepository(fileSystems);
 
                 var partialView = new PartialView(PartialViewType.PartialView, "test-path-1.cshtml") { Content = "// partialView" };
                 repository.Save(partialView);

src/Umbraco.Tests/Persistence/Repositories/PublicAccessRepositoryTest.cs

@@ -307,7 +307,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         private DocumentRepository CreateRepository(IScopeProvider provider, out ContentTypeRepository contentTypeRepository)
         {
             var accessor = (IScopeAccessor) provider;
-            var templateRepository = new TemplateRepository(accessor, CacheHelper, Logger, Mock.Of<ITemplatesSection>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>());
+            var templateRepository = new TemplateRepository(accessor, CacheHelper, Logger, Mock.Of<ITemplatesSection>(), TestObjects.GetFileSystemsMock());
             var tagRepository = new TagRepository(accessor, CacheHelper, Logger);
             contentTypeRepository = new ContentTypeRepository(accessor, CacheHelper, Logger, templateRepository);
             var languageRepository = new LanguageRepository(accessor, CacheHelper, Logger);

src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs

@@ -30,8 +30,8 @@ namespace Umbraco.Tests.Persistence.Repositories
         private RelationRepository CreateRepository(IScopeProvider provider, out RelationTypeRepository relationTypeRepository)
         {
             var accessor = (IScopeAccessor) provider;
-            relationTypeRepository = new RelationTypeRepository(accessor, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
-            var repository = new RelationRepository(accessor, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), relationTypeRepository);
+            relationTypeRepository = new RelationTypeRepository(accessor, CacheHelper.Disabled, Mock.Of<ILogger>());
+            var repository = new RelationRepository(accessor, Mock.Of<ILogger>(), relationTypeRepository);
             return repository;
         }
 
@@ -266,12 +266,11 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var relationTypeRepository = new RelationTypeRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
-                var relationRepository = new RelationRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), relationTypeRepository);
+                var relationTypeRepository = new RelationTypeRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
+                var relationRepository = new RelationRepository((IScopeAccessor) provider, Mock.Of<ILogger>(), relationTypeRepository);
 
                 relationTypeRepository.Save(relateContent);
-                relationTypeRepository.Save(relateContentType);
-                
+                relationTypeRepository.Save(relateContentType);                
 
                 //Create and Save ContentType "umbTextpage" -> (NodeDto.NodeIdSeed)
                 ContentType contentType = MockedContentTypes.CreateSimpleContentType("umbTextpage", "Textpage");

src/Umbraco.Tests/Persistence/Repositories/RelationTypeRepositoryTest.cs

@@ -28,7 +28,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private RelationTypeRepository CreateRepository(IScopeProvider provider)
         {
-            return new RelationTypeRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+            return new RelationTypeRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
         }
 
 
@@ -232,7 +232,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = ScopeProvider.CreateScope())
             {
-                var repository = new RelationTypeRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new RelationTypeRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 repository.Save(relateContent);//Id 2
                 repository.Save(relateContentType);//Id 3

src/Umbraco.Tests/Persistence/Repositories/ScriptRepositoryTest.cs

@@ -4,13 +4,10 @@ using System.Text;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core.Configuration.UmbracoSettings;
-using Umbraco.Core.Composing;
 using Umbraco.Core.IO;
 using Umbraco.Core.Models;
-using Umbraco.Core.Persistence.Repositories;
 using Umbraco.Core.Persistence.Repositories.Implement;
 using Umbraco.Core.PropertyEditors;
-using Umbraco.Core.Scoping;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Tests.Testing;
 
@@ -20,13 +17,16 @@ namespace Umbraco.Tests.Persistence.Repositories
     [UmbracoTest(WithApplication = true, Database = UmbracoTestOptions.Database.NewEmptyPerFixture)]
     public class ScriptRepositoryTest : TestWithDatabaseBase
     {
+        private IFileSystems _fileSystems;
         private IFileSystem _fileSystem;
 
         public override void SetUp()
         {
             base.SetUp();
 
+            _fileSystems = Mock.Of<IFileSystems>();
             _fileSystem = new PhysicalFileSystem(SystemDirectories.Scripts);
+            Mock.Get(_fileSystems).Setup(x => x.ScriptsFileSystem).Returns(_fileSystem);
             using (var stream = CreateStream("Umbraco.Sys.registerNamespace(\"Umbraco.Utils\");"))
             {
                 _fileSystem.AddFile("test-script.js", stream);
@@ -37,7 +37,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             base.Compose();
 
-            Container.RegisterSingleton(f => new DataEditorCollection(Enumerable.Empty<DataEditor>()));
+            Composition.RegisterUnique(f => new DataEditorCollection(Enumerable.Empty<DataEditor>()));
         }
 
         [Test]
@@ -47,9 +47,8 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = ScopeProvider.CreateScope())
             {
-
                 // Act
-                var repository = new ScriptRepository(_fileSystem, Mock.Of<IContentSection>());
+                var repository = new ScriptRepository(_fileSystems, Mock.Of<IContentSection>());
 
                 // Assert
                 Assert.That(repository, Is.Not.Null);
@@ -63,12 +62,12 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = ScopeProvider.CreateScope())
             {
-                var repository = new ScriptRepository(_fileSystem, Mock.Of<IContentSection>());
+                var repository = new ScriptRepository(_fileSystems, Mock.Of<IContentSection>());
 
                 // Act
                 var script = new Script("test-add-script.js") { Content = "/// <reference name=\"MicrosoftAjax.js\"/>" };
                 repository.Save(script);
-                
+
 
                 //Assert
                 Assert.That(_fileSystem.FileExists("test-add-script.js"), Is.True);
@@ -82,16 +81,16 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = ScopeProvider.CreateScope())
             {
-                var repository = new ScriptRepository(_fileSystem, Mock.Of<IContentSection>());
+                var repository = new ScriptRepository(_fileSystems, Mock.Of<IContentSection>());
 
                 // Act
                 var script = new Script("test-updated-script.js") { Content = "/// <reference name=\"MicrosoftAjax.js\"/>" };
                 repository.Save(script);
-                
+
 
                 script.Content = "/// <reference name=\"MicrosoftAjax-Updated.js\"/>";
                 repository.Save(script);
-                
+
 
                 var scriptUpdated = repository.Get("test-updated-script.js");
 
@@ -108,12 +107,12 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = ScopeProvider.CreateScope())
             {
-                var repository = new ScriptRepository(_fileSystem, Mock.Of<IContentSection>());
+                var repository = new ScriptRepository(_fileSystems, Mock.Of<IContentSection>());
 
                 // Act
                 var script = repository.Get("test-script.js");
                 repository.Delete(script);
-                
+
 
                 // Assert
 
@@ -128,7 +127,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = ScopeProvider.CreateScope())
             {
-                var repository = new ScriptRepository(_fileSystem, Mock.Of<IContentSection>());
+                var repository = new ScriptRepository(_fileSystems, Mock.Of<IContentSection>());
 
                 // Act
                 var exists = repository.Get("test-script.js");
@@ -147,7 +146,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = ScopeProvider.CreateScope())
             {
-                var repository = new ScriptRepository(_fileSystem, Mock.Of<IContentSection>());
+                var repository = new ScriptRepository(_fileSystems, Mock.Of<IContentSection>());
 
                 var script = new Script("test-script1.js") { Content = "/// <reference name=\"MicrosoftAjax.js\"/>" };
                 repository.Save(script);
@@ -155,7 +154,7 @@ namespace Umbraco.Tests.Persistence.Repositories
                 repository.Save(script2);
                 var script3 = new Script("test-script3.js") { Content = "/// <reference name=\"MicrosoftAjax.js\"/>" };
                 repository.Save(script3);
-                
+
 
                 // Act
                 var scripts = repository.GetMany();
@@ -175,7 +174,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = ScopeProvider.CreateScope())
             {
-                var repository = new ScriptRepository(_fileSystem, Mock.Of<IContentSection>());
+                var repository = new ScriptRepository(_fileSystems, Mock.Of<IContentSection>());
 
                 var script = new Script("test-script1.js") { Content = "/// <reference name=\"MicrosoftAjax.js\"/>" };
                 repository.Save(script);
@@ -183,7 +182,7 @@ namespace Umbraco.Tests.Persistence.Repositories
                 repository.Save(script2);
                 var script3 = new Script("test-script3.js") { Content = "/// <reference name=\"MicrosoftAjax.js\"/>" };
                 repository.Save(script3);
-                
+
 
                 // Act
                 var scripts = repository.GetMany("test-script1.js", "test-script2.js");
@@ -203,7 +202,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = ScopeProvider.CreateScope())
             {
-                var repository = new ScriptRepository(_fileSystem, Mock.Of<IContentSection>());
+                var repository = new ScriptRepository(_fileSystems, Mock.Of<IContentSection>());
 
                 // Act
                 var exists = repository.Exists("test-script.js");
@@ -222,17 +221,17 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = ScopeProvider.CreateScope())
             {
-                var repository = new ScriptRepository(_fileSystem, Mock.Of<IContentSection>());
+                var repository = new ScriptRepository(_fileSystems, Mock.Of<IContentSection>());
 
                 var script = new Script("test-move-script.js") { Content = content };
                 repository.Save(script);
-                
+
 
                 // Act
                 script = repository.Get("test-move-script.js");
                 script.Path = "moved/test-move-script.js";
                 repository.Save(script);
-                
+
 
                 var existsOld = repository.Exists("test-move-script.js");
                 var existsNew = repository.Exists("moved/test-move-script.js");
@@ -255,11 +254,11 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = ScopeProvider.CreateScope())
             {
-                var repository = new ScriptRepository(_fileSystem, Mock.Of<IContentSection>());
+                var repository = new ScriptRepository(_fileSystems, Mock.Of<IContentSection>());
 
                 var script = new Script("test-path-1.js") { Content = "// script" };
                 repository.Save(script);
-                
+
                 Assert.IsTrue(_fileSystem.FileExists("test-path-1.js"));
                 Assert.AreEqual("test-path-1.js", script.Path);
                 Assert.AreEqual("/scripts/test-path-1.js", script.VirtualPath);
@@ -267,14 +266,14 @@ namespace Umbraco.Tests.Persistence.Repositories
                 //ensure you can prefix the same path as the root path name
                 script = new Script("scripts/path-2/test-path-2.js") { Content = "// script" };
                 repository.Save(script);
-                
+
                 Assert.IsTrue(_fileSystem.FileExists("scripts/path-2/test-path-2.js"));
                 Assert.AreEqual("scripts\\path-2\\test-path-2.js", script.Path);
                 Assert.AreEqual("/scripts/scripts/path-2/test-path-2.js", script.VirtualPath);
 
                 script = new Script("path-2/test-path-2.js") { Content = "// script" };
                 repository.Save(script);
-                
+
                 Assert.IsTrue(_fileSystem.FileExists("path-2/test-path-2.js"));
                 Assert.AreEqual("path-2\\test-path-2.js", script.Path); // fixed in 7.3 - 7.2.8 does not update the path
                 Assert.AreEqual("/scripts/path-2/test-path-2.js", script.VirtualPath);
@@ -286,7 +285,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
                 script = new Script("path-2\\test-path-3.js") { Content = "// script" };
                 repository.Save(script);
-                
+
                 Assert.IsTrue(_fileSystem.FileExists("path-2/test-path-3.js"));
                 Assert.AreEqual("path-2\\test-path-3.js", script.Path);
                 Assert.AreEqual("/scripts/path-2/test-path-3.js", script.VirtualPath);
@@ -328,11 +327,11 @@ namespace Umbraco.Tests.Persistence.Repositories
             base.TearDown();
 
             //Delete all files
-            Purge((PhysicalFileSystem) _fileSystem, "");
-            _fileSystem = null;
+            Purge(_fileSystems.ScriptsFileSystem, "");
+            _fileSystems = null;
         }
 
-        private void Purge(PhysicalFileSystem fs, string path)
+        private void Purge(IFileSystem fs, string path)
         {
             var files = fs.GetFiles(path, "*.js");
             foreach (var file in files)

src/Umbraco.Tests/Persistence/Repositories/StylesheetRepositoryTest.cs

@@ -2,6 +2,7 @@
 using System.IO;
 using System.Linq;
 using System.Text;
+using Moq;
 using NUnit.Framework;
 using Umbraco.Core.IO;
 using Umbraco.Core.Models;
@@ -15,13 +16,16 @@ namespace Umbraco.Tests.Persistence.Repositories
     [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerFixture)]
     public class StylesheetRepositoryTest : TestWithDatabaseBase
     {
+        private IFileSystems _fileSystems;
         private IFileSystem _fileSystem;
 
         public override void SetUp()
         {
             base.SetUp();
 
+            _fileSystems = Mock.Of<IFileSystems>();
             _fileSystem = new PhysicalFileSystem(SystemDirectories.Css);
+            Mock.Get(_fileSystems).Setup(x => x.StylesheetsFileSystem).Returns(_fileSystem);
             var stream = CreateStream("body {background:#EE7600; color:#FFF;}");
             _fileSystem.AddFile("styles.css", stream);
         }
@@ -30,11 +34,10 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Instantiate_Repository()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
                 // Act
-                var repository = new StylesheetRepository(_fileSystem);
+                var repository = new StylesheetRepository(_fileSystems);
 
 
                 // Assert
@@ -46,15 +49,14 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Perform_Add()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = new StylesheetRepository(_fileSystem);
+                var repository = new StylesheetRepository(_fileSystems);
 
                 // Act
                 var stylesheet = new Stylesheet("test-add.css") { Content = "body { color:#000; } .bold {font-weight:bold;}" };
                 repository.Save(stylesheet);
-                
+
 
                 //Assert
                 Assert.That(_fileSystem.FileExists("test-add.css"), Is.True);
@@ -65,20 +67,19 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Perform_Update()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = new StylesheetRepository(_fileSystem);
+                var repository = new StylesheetRepository(_fileSystems);
 
                 // Act
                 var stylesheet = new Stylesheet("test-update.css") { Content = "body { color:#000; } .bold {font-weight:bold;}" };
                 repository.Save(stylesheet);
-                
+
 
                 var stylesheetUpdate = repository.Get("test-update.css");
                 stylesheetUpdate.Content = "body { color:#000; }";
                 repository.Save(stylesheetUpdate);
-                
+
 
                 var stylesheetUpdated = repository.Get("test-update.css");
 
@@ -93,20 +94,19 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Perform_Update_With_Property()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = new StylesheetRepository(_fileSystem);
+                var repository = new StylesheetRepository(_fileSystems);
 
                 // Act
                 var stylesheet = new Stylesheet("test-update.css") { Content = "body { color:#000; } .bold {font-weight:bold;}" };
                 repository.Save(stylesheet);
-                
+
 
                 stylesheet.AddProperty(new StylesheetProperty("Test", "p", "font-size:2em;"));
 
                 repository.Save(stylesheet);
-                
+
 
                 //re-get
                 stylesheet = repository.Get(stylesheet.Name);
@@ -121,15 +121,14 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Throws_When_Adding_Duplicate_Properties()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = new StylesheetRepository(_fileSystem);
+                var repository = new StylesheetRepository(_fileSystems);
 
                 // Act
                 var stylesheet = new Stylesheet("test-update.css") { Content = "body { color:#000; } .bold {font-weight:bold;}" };
                 repository.Save(stylesheet);
-                
+
 
                 stylesheet.AddProperty(new StylesheetProperty("Test", "p", "font-size:2em;"));
 
@@ -141,18 +140,17 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Perform_Delete()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = new StylesheetRepository(_fileSystem);
+                var repository = new StylesheetRepository(_fileSystems);
 
                 // Act
                 var stylesheet = new Stylesheet("test-delete.css") { Content = "body { color:#000; } .bold {font-weight:bold;}" };
                 repository.Save(stylesheet);
-                
+
 
                 repository.Delete(stylesheet);
-                
+
 
                 //Assert
                 Assert.That(_fileSystem.FileExists("test-delete.css"), Is.False);
@@ -163,10 +161,9 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Perform_Get()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = new StylesheetRepository(_fileSystem);
+                var repository = new StylesheetRepository(_fileSystems);
 
                 // Act
                 var stylesheet = repository.Get("styles.css");
@@ -183,14 +180,13 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Perform_GetAll()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = new StylesheetRepository(_fileSystem);
+                var repository = new StylesheetRepository(_fileSystems);
 
                 var stylesheet = new Stylesheet("styles-v2.css") { Content = "body { color:#000; } .bold {font-weight:bold;}" };
                 repository.Save(stylesheet);
-                
+
 
                 // Act
                 var stylesheets = repository.GetMany();
@@ -207,14 +203,13 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Perform_GetAll_With_Params()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = new StylesheetRepository(_fileSystem);
+                var repository = new StylesheetRepository(_fileSystems);
 
                 var stylesheet = new Stylesheet("styles-v2.css") { Content = "body { color:#000; } .bold {font-weight:bold;}" };
                 repository.Save(stylesheet);
-                
+
 
                 // Act
                 var stylesheets = repository.GetMany("styles-v2.css", "styles.css");
@@ -231,10 +226,9 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Perform_Exists()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = new StylesheetRepository(_fileSystem);
+                var repository = new StylesheetRepository(_fileSystems);
 
                 // Act
                 var exists = repository.Exists("styles.css");
@@ -249,21 +243,20 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             // unless noted otherwise, no changes / 7.2.8
 
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = new StylesheetRepository(_fileSystem);
+                var repository = new StylesheetRepository(_fileSystems);
 
                 var stylesheet = new Stylesheet("test-path-1.css") { Content = "body { color:#000; } .bold {font-weight:bold;}" };
                 repository.Save(stylesheet);
-                
+
                 Assert.IsTrue(_fileSystem.FileExists("test-path-1.css"));
                 Assert.AreEqual("test-path-1.css", stylesheet.Path);
                 Assert.AreEqual("/css/test-path-1.css", stylesheet.VirtualPath);
 
                 stylesheet = new Stylesheet("path-2/test-path-2.css") { Content = "body { color:#000; } .bold {font-weight:bold;}" };
                 repository.Save(stylesheet);
-                
+
                 Assert.IsTrue(_fileSystem.FileExists("path-2/test-path-2.css"));
                 Assert.AreEqual("path-2\\test-path-2.css", stylesheet.Path); // fixed in 7.3 - 7.2.8 does not update the path
                 Assert.AreEqual("/css/path-2/test-path-2.css", stylesheet.VirtualPath);
@@ -275,7 +268,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
                 stylesheet = new Stylesheet("path-2\\test-path-3.css") { Content = "body { color:#000; } .bold {font-weight:bold;}" };
                 repository.Save(stylesheet);
-                
+
                 Assert.IsTrue(_fileSystem.FileExists("path-2/test-path-3.css"));
                 Assert.AreEqual("path-2\\test-path-3.css", stylesheet.Path);
                 Assert.AreEqual("/css/path-2/test-path-3.css", stylesheet.VirtualPath);

src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs

@@ -1,6 +1,7 @@
 using System.Linq;
 using Moq;
 using NUnit.Framework;
+using Umbraco.Core.Cache;
 using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.IO;
 using Umbraco.Core.Models;
@@ -946,26 +947,26 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private TagRepository CreateRepository(IScopeProvider provider)
         {
-            return new TagRepository((IScopeAccessor) provider, DisabledCache, Logger);
+            return new TagRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger);
         }
 
         private DocumentRepository CreateContentRepository(IScopeProvider provider, out ContentTypeRepository contentTypeRepository)
         {
             var accessor = (IScopeAccessor) provider;
-            var templateRepository = new TemplateRepository(accessor, DisabledCache, Logger, Mock.Of<ITemplatesSection>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>());
-            var tagRepository = new TagRepository(accessor, DisabledCache, Logger);
-            contentTypeRepository = new ContentTypeRepository(accessor, DisabledCache, Logger, templateRepository);
-            var languageRepository = new LanguageRepository(accessor, DisabledCache, Logger);
-            var repository = new DocumentRepository(accessor, DisabledCache, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, Mock.Of<IContentSection>());
+            var templateRepository = new TemplateRepository(accessor, CacheHelper.Disabled, Logger, Mock.Of<ITemplatesSection>(), TestObjects.GetFileSystemsMock());
+            var tagRepository = new TagRepository(accessor, CacheHelper.Disabled, Logger);
+            contentTypeRepository = new ContentTypeRepository(accessor, CacheHelper.Disabled, Logger, templateRepository);
+            var languageRepository = new LanguageRepository(accessor, CacheHelper.Disabled, Logger);
+            var repository = new DocumentRepository(accessor, CacheHelper.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, Mock.Of<IContentSection>());
             return repository;
         }
 
         private MediaRepository CreateMediaRepository(IScopeProvider provider, out MediaTypeRepository mediaTypeRepository)
         {
             var accessor = (IScopeAccessor) provider;
-            var tagRepository = new TagRepository(accessor, DisabledCache, Logger);
-            mediaTypeRepository = new MediaTypeRepository(accessor, DisabledCache, Logger);
-            var repository = new MediaRepository(accessor, DisabledCache, Logger, mediaTypeRepository, tagRepository, Mock.Of<IContentSection>(), Mock.Of<ILanguageRepository>());
+            var tagRepository = new TagRepository(accessor, CacheHelper.Disabled, Logger);
+            mediaTypeRepository = new MediaTypeRepository(accessor, CacheHelper.Disabled, Logger);
+            var repository = new MediaRepository(accessor, CacheHelper.Disabled, Logger, mediaTypeRepository, tagRepository, Mock.Of<IContentSection>(), Mock.Of<ILanguageRepository>());
             return repository;
         }
     }

src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs

@@ -6,6 +6,7 @@ using System.Text;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
+using Umbraco.Core.Cache;
 using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.IO;
 using Umbraco.Core.Models;
@@ -22,47 +23,46 @@ namespace Umbraco.Tests.Persistence.Repositories
     [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
     public class TemplateRepositoryTest : TestWithDatabaseBase
     {
-        private IFileSystem _masterPageFileSystem;
-        private IFileSystem _viewsFileSystem;
+        private IFileSystems _fileSystems;
 
         private ITemplateRepository CreateRepository(IScopeProvider provider, ITemplatesSection templatesSection = null)
         {
-            return new TemplateRepository((IScopeAccessor) provider, DisabledCache, Logger,
+            return new TemplateRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger,
                 templatesSection ?? Mock.Of<ITemplatesSection>(t => t.DefaultRenderingEngine == RenderingEngine.Mvc),
-                _masterPageFileSystem, _viewsFileSystem);
+                _fileSystems);
         }
 
         public override void SetUp()
         {
             base.SetUp();
 
-            _masterPageFileSystem = new PhysicalFileSystem(SystemDirectories.Masterpages);
-            _viewsFileSystem = new PhysicalFileSystem(SystemDirectories.MvcViews);
+            _fileSystems = Mock.Of<IFileSystems>();
+            var masterPageFileSystem = new PhysicalFileSystem(SystemDirectories.Masterpages);
+            Mock.Get(_fileSystems).Setup(x => x.MasterPagesFileSystem).Returns(masterPageFileSystem);
+            var viewsFileSystem = new PhysicalFileSystem(SystemDirectories.MvcViews);
+            Mock.Get(_fileSystems).Setup(x => x.MvcViewsFileSystem).Returns(viewsFileSystem);
         }
 
         [Test]
         public void Can_Instantiate_Repository()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 // Assert
                 Assert.That(repository, Is.Not.Null);
             }
-
         }
 
         [Test]
         public void Can_Perform_Add_MasterPage_Detect_Content()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 // Act
                 var template = new Template("test", "test")
@@ -70,32 +70,28 @@ namespace Umbraco.Tests.Persistence.Repositories
                     Content = @"<%@ Master Language=""C#"" %>"
                 };
                 repository.Save(template);
-                
 
                 //Assert
                 Assert.That(repository.Get("test"), Is.Not.Null);
-                Assert.That(_masterPageFileSystem.FileExists("test.master"), Is.True);
+                Assert.That(_fileSystems.MasterPagesFileSystem.FileExists("test.master"), Is.True);
             }
-
         }
 
         [Test]
         public void Can_Perform_Add_MasterPage_With_Default_Content()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider, Mock.Of<ITemplatesSection>(x => x.DefaultRenderingEngine == RenderingEngine.WebForms));
+                var repository = CreateRepository(ScopeProvider, Mock.Of<ITemplatesSection>(x => x.DefaultRenderingEngine == RenderingEngine.WebForms));
 
                 // Act
                 var template = new Template("test", "test");
                 repository.Save(template);
-                
 
                 //Assert
                 Assert.That(repository.Get("test"), Is.Not.Null);
-                Assert.That(_masterPageFileSystem.FileExists("test.master"), Is.True);
+                Assert.That(_fileSystems.MasterPagesFileSystem.FileExists("test.master"), Is.True);
                 Assert.AreEqual(@"<%@ Master Language=""C#"" MasterPageFile=""~/umbraco/masterpages/default.master"" AutoEventWireup=""true"" %>
 
 <asp:Content ContentPlaceHolderID=""ContentPlaceHolderDefault"" runat=""server"">
@@ -103,47 +99,41 @@ namespace Umbraco.Tests.Persistence.Repositories
 </asp:Content>
 ".StripWhitespace(), template.Content.StripWhitespace());
             }
-
         }
 
         [Test]
         public void Can_Perform_Add_MasterPage_With_Default_Content_With_Parent()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider, Mock.Of<ITemplatesSection>(x => x.DefaultRenderingEngine == RenderingEngine.WebForms));
+                var repository = CreateRepository(ScopeProvider, Mock.Of<ITemplatesSection>(x => x.DefaultRenderingEngine == RenderingEngine.WebForms));
 
                 //NOTE: This has to be persisted first
                 var template = new Template("test", "test");
                 repository.Save(template);
-                
 
                 // Act
                 var template2 = new Template("test2", "test2");
                 template2.SetMasterTemplate(template);
                 repository.Save(template2);
-                
 
                 //Assert
                 Assert.That(repository.Get("test2"), Is.Not.Null);
-                Assert.That(_masterPageFileSystem.FileExists("test2.master"), Is.True);
+                Assert.That(_fileSystems.MasterPagesFileSystem.FileExists("test2.master"), Is.True);
                 Assert.AreEqual(@"<%@ Master Language=""C#"" MasterPageFile=""~/masterpages/test.master"" AutoEventWireup=""true"" %>
 
 ".StripWhitespace(), template2.Content.StripWhitespace());
             }
-
         }
 
         [Test]
         public void Can_Perform_Add_View()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 // Act
                 var template = new Template("test", "test");
@@ -152,19 +142,17 @@ namespace Umbraco.Tests.Persistence.Repositories
 
                 //Assert
                 Assert.That(repository.Get("test"), Is.Not.Null);
-                Assert.That(_viewsFileSystem.FileExists("test.cshtml"), Is.True);
+                Assert.That(_fileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.True);
             }
-
         }
 
         [Test]
         public void Can_Perform_Add_View_With_Default_Content()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 // Act
                 var template = new Template("test", "test")
@@ -172,41 +160,36 @@ namespace Umbraco.Tests.Persistence.Repositories
                     Content = ViewHelper.GetDefaultFileContent()
                 };
                 repository.Save(template);
-                
 
                 //Assert
                 Assert.That(repository.Get("test"), Is.Not.Null);
-                Assert.That(_viewsFileSystem.FileExists("test.cshtml"), Is.True);
+                Assert.That(_fileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.True);
                 Assert.AreEqual(
                     @"@inherits Umbraco.Web.Mvc.UmbracoViewPage @{ Layout = null;}".StripWhitespace(),
                     template.Content.StripWhitespace());
             }
-
         }
 
         [Test]
         public void Can_Perform_Add_View_With_Default_Content_With_Parent()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 //NOTE: This has to be persisted first
                 var template = new Template("test", "test");
                 repository.Save(template);
-                
 
                 // Act
                 var template2 = new Template("test2", "test2");
                 template2.SetMasterTemplate(template);
                 repository.Save(template2);
-                
 
                 //Assert
                 Assert.That(repository.Get("test2"), Is.Not.Null);
-                Assert.That(_viewsFileSystem.FileExists("test2.cshtml"), Is.True);
+                Assert.That(_fileSystems.MvcViewsFileSystem.FileExists("test2.cshtml"), Is.True);
                 Assert.AreEqual(
                     "@inherits Umbraco.Web.Mvc.UmbracoViewPage @{ Layout = \"test.cshtml\";}".StripWhitespace(),
                     template2.Content.StripWhitespace());
@@ -217,10 +200,9 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Perform_Add_Unique_Alias()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 // Act
                 var template = new Template("test", "test")
@@ -228,29 +210,25 @@ namespace Umbraco.Tests.Persistence.Repositories
                     Content = ViewHelper.GetDefaultFileContent()
                 };
                 repository.Save(template);
-                
 
                 var template2 = new Template("test", "test")
                 {
                     Content = ViewHelper.GetDefaultFileContent()
                 };
                 repository.Save(template2);
-                
 
                 //Assert
                 Assert.AreEqual("test1", template2.Alias);
             }
-
         }
 
         [Test]
         public void Can_Perform_Update_Unique_Alias()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 // Act
                 var template = new Template("test", "test")
@@ -258,35 +236,30 @@ namespace Umbraco.Tests.Persistence.Repositories
                     Content = ViewHelper.GetDefaultFileContent()
                 };
                 repository.Save(template);
-                
 
                 var template2 = new Template("test1", "test1")
                 {
                     Content = ViewHelper.GetDefaultFileContent()
                 };
                 repository.Save(template2);
-                
 
                 template.Alias = "test1";
                 repository.Save(template);
-                
 
                 //Assert
                 Assert.AreEqual("test11", template.Alias);
-                Assert.That(_viewsFileSystem.FileExists("test11.cshtml"), Is.True);
-                Assert.That(_viewsFileSystem.FileExists("test.cshtml"), Is.False);
+                Assert.That(_fileSystems.MvcViewsFileSystem.FileExists("test11.cshtml"), Is.True);
+                Assert.That(_fileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.False);
             }
-
         }
 
         [Test]
         public void Can_Perform_Update_MasterPage()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 // Act
                 var template = new Template("test", "test")
@@ -294,30 +267,25 @@ namespace Umbraco.Tests.Persistence.Repositories
                     Content = @"<%@ Master Language=""C#"" %>"
                 };
                 repository.Save(template);
-                
 
                 template.Content = @"<%@ Master Language=""VB"" %>";
                 repository.Save(template);
-                
 
                 var updated = repository.Get("test");
 
                 // Assert
-                Assert.That(_masterPageFileSystem.FileExists("test.master"), Is.True);
+                Assert.That(_fileSystems.MasterPagesFileSystem.FileExists("test.master"), Is.True);
                 Assert.That(updated.Content, Is.EqualTo(@"<%@ Master Language=""VB"" %>"));
             }
-
-
         }
 
         [Test]
         public void Can_Perform_Update_View()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 // Act
                 var template = new Template("test", "test")
@@ -325,16 +293,14 @@ namespace Umbraco.Tests.Persistence.Repositories
                     Content = ViewHelper.GetDefaultFileContent()
                 };
                 repository.Save(template);
-                
 
                 template.Content += "<html></html>";
                 repository.Save(template);
-                
 
                 var updated = repository.Get("test");
 
                 // Assert
-                Assert.That(_viewsFileSystem.FileExists("test.cshtml"), Is.True);
+                Assert.That(_fileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.True);
                 Assert.That(updated.Content, Is.EqualTo(ViewHelper.GetDefaultFileContent() + "<html></html>"));
             }
         }
@@ -343,27 +309,24 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Perform_Delete_MasterPage()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 var template = new Template("test", "test")
                 {
                     Content = @"<%@ Master Language=""C#"" %>"
                 };
                 repository.Save(template);
-                
 
                 // Act
                 var templates = repository.Get("test");
-                Assert.That(_masterPageFileSystem.FileExists("test.master"), Is.True);
+                Assert.That(_fileSystems.MasterPagesFileSystem.FileExists("test.master"), Is.True);
                 repository.Delete(templates);
-                
 
                 // Assert
                 Assert.IsNull(repository.Get("test"));
-                Assert.That(_masterPageFileSystem.FileExists("test.master"), Is.False);
+                Assert.That(_fileSystems.MasterPagesFileSystem.FileExists("test.master"), Is.False);
             }
         }
 
@@ -371,27 +334,24 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Perform_Delete_View()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 var template = new Template("test", "test")
                 {
                     Content = ViewHelper.GetDefaultFileContent()
                 };
                 repository.Save(template);
-                
 
                 // Act
                 var templates = repository.Get("test");
-                Assert.That(_viewsFileSystem.FileExists("test.cshtml"), Is.True);
+                Assert.That(_fileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.True);
                 repository.Delete(templates);
-                
 
                 // Assert
                 Assert.IsNull(repository.Get("test"));
-                Assert.That(_viewsFileSystem.FileExists("test.cshtml"), Is.False);
+                Assert.That(_fileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.False);
             }
         }
 
@@ -399,39 +359,33 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Perform_Delete_When_Assigned_To_Doc()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var templateRepository = CreateRepository(provider);
+                var templateRepository = CreateRepository(ScopeProvider);
 
-                var tagRepository = new TagRepository((IScopeAccessor) provider, DisabledCache, Logger);
-                var contentTypeRepository = new ContentTypeRepository((IScopeAccessor) provider, DisabledCache, Logger, templateRepository);
-                var languageRepository = new LanguageRepository((IScopeAccessor) provider, DisabledCache, Logger);
-                var contentRepo = new DocumentRepository((IScopeAccessor) provider, DisabledCache, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, Mock.Of<IContentSection>());
+                var tagRepository = new TagRepository((IScopeAccessor) ScopeProvider, CacheHelper.Disabled, Logger);
+                var contentTypeRepository = new ContentTypeRepository((IScopeAccessor) ScopeProvider, CacheHelper.Disabled, Logger, templateRepository);
+                var languageRepository = new LanguageRepository((IScopeAccessor) ScopeProvider, CacheHelper.Disabled, Logger);
+                var contentRepo = new DocumentRepository((IScopeAccessor) ScopeProvider, CacheHelper.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, Mock.Of<IContentSection>());
 
                 var contentType = MockedContentTypes.CreateSimpleContentType("umbTextpage2", "Textpage");
                 ServiceContext.FileService.SaveTemplate(contentType.DefaultTemplate); // else, FK violation on contentType!
                 contentTypeRepository.Save(contentType);
                 var textpage = MockedContent.CreateSimpleContent(contentType);
                 contentRepo.Save(textpage);
-                
-
 
                 var template = new Template("test", "test")
                 {
                     Content = @"<%@ Master Language=""C#"" %>"
                 };
                 templateRepository.Save(template);
-                
 
                 textpage.Template = template;
                 contentRepo.Save(textpage);
-                
 
                 // Act
                 var templates = templateRepository.Get("test");
                 templateRepository.Delete(templates);
-                
 
                 // Assert
                 Assert.IsNull(templateRepository.Get("test"));
@@ -442,10 +396,9 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Perform_Delete_On_Nested_Templates()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 var parent = new Template("parent", "parent")
                 {
@@ -466,12 +419,10 @@ namespace Umbraco.Tests.Persistence.Repositories
                 repository.Save(parent);
                 repository.Save(child);
                 repository.Save(baby);
-                
 
                 // Act
                 var templates = repository.Get("parent");
                 repository.Delete(templates);
-                
 
                 // Assert
                 Assert.IsNull(repository.Get("test"));
@@ -482,10 +433,9 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Get_All()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 var created = CreateHierarchy(repository).ToArray();
 
@@ -510,10 +460,9 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Get_Children()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 var created = CreateHierarchy(repository).ToArray();
 
@@ -521,7 +470,6 @@ namespace Umbraco.Tests.Persistence.Repositories
                 var childrenById = repository.GetChildren(created[1].Id);
                 var childrenByAlias = repository.GetChildren(created[1].Alias);
 
-
                 // Assert
                 Assert.AreEqual(2, childrenById.Count());
                 Assert.AreEqual(2, childrenById.DistinctBy(x => x.Id).Count());
@@ -534,17 +482,15 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Get_Children_At_Root()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 CreateHierarchy(repository).ToArray();
 
                 // Act
                 var children = repository.GetChildren(-1);
 
-
                 // Assert
                 Assert.AreEqual(1, children.Count());
                 Assert.AreEqual(1, children.DistinctBy(x => x.Id).Count());
@@ -555,18 +501,15 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Can_Get_Descendants()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
-
+                var repository = CreateRepository(ScopeProvider);
                 var created = CreateHierarchy(repository).ToArray();
 
                 // Act
                 var descendantsById = repository.GetDescendants(created[1].Id);
                 var descendantsByAlias = repository.GetDescendants(created[1].Alias);
 
-
                 // Assert
                 Assert.AreEqual(3, descendantsById.Count());
                 Assert.AreEqual(3, descendantsById.DistinctBy(x => x.Id).Count());
@@ -580,10 +523,9 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Path_Is_Set_Correctly_On_Creation()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 var parent = new Template("parent", "parent");
                 var child1 = new Template("child1", "child1");
@@ -612,7 +554,6 @@ namespace Umbraco.Tests.Persistence.Repositories
                 baby2.MasterTemplateAlias = toddler4.Alias;
                 baby2.MasterTemplateId = new Lazy<int>(() => toddler4.Id);
 
-
                 // Act
                 repository.Save(parent);
                 repository.Save(child1);
@@ -623,7 +564,6 @@ namespace Umbraco.Tests.Persistence.Repositories
                 repository.Save(toddler4);
                 repository.Save(baby1);
                 repository.Save(baby2);
-                
 
                 // Assert
                 Assert.AreEqual(string.Format("-1,{0}", parent.Id), parent.Path);
@@ -643,10 +583,9 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Path_Is_Set_Correctly_On_Update()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 var parent = new Template("parent", "parent");
                 var child1 = new Template("child1", "child1");
@@ -668,12 +607,10 @@ namespace Umbraco.Tests.Persistence.Repositories
                 repository.Save(child2);
                 repository.Save(toddler1);
                 repository.Save(toddler2);
-                
 
                 //Act
                 toddler2.SetMasterTemplate(child2);
                 repository.Save(toddler2);
-                
 
                 //Assert
                 Assert.AreEqual($"-1,{parent.Id},{child2.Id},{toddler2.Id}", toddler2.Path);
@@ -684,10 +621,9 @@ namespace Umbraco.Tests.Persistence.Repositories
         public void Path_Is_Set_Correctly_On_Update_With_Master_Template_Removal()
         {
             // Arrange
-            var provider = TestObjects.GetScopeProvider(Logger);
-            using (var scope = ScopeProvider.CreateScope())
+            using (ScopeProvider.CreateScope())
             {
-                var repository = CreateRepository(provider);
+                var repository = CreateRepository(ScopeProvider);
 
                 var parent = new Template("parent", "parent");
                 var child1 = new Template("child1", "child1");
@@ -697,12 +633,10 @@ namespace Umbraco.Tests.Persistence.Repositories
 
                 repository.Save(parent);
                 repository.Save(child1);
-                
 
                 //Act
                 child1.SetMasterTemplate(null);
                 repository.Save(child1);
-                
 
                 //Assert
                 Assert.AreEqual($"-1,{child1.Id}", child1.Path);
@@ -714,21 +648,18 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             base.TearDown();
 
-            _masterPageFileSystem = null;
-            _viewsFileSystem = null;
+            _fileSystems  = null;
+
             //Delete all files
             var fsMaster = new PhysicalFileSystem(SystemDirectories.Masterpages);
             var masterPages = fsMaster.GetFiles("", "*.master");
             foreach (var file in masterPages)
-            {
                 fsMaster.DeleteFile(file);
-            }
+
             var fsViews = new PhysicalFileSystem(SystemDirectories.MvcViews);
-            var views = fsMaster.GetFiles("", "*.cshtml");
+            var views = fsViews.GetFiles("", "*.cshtml");
             foreach (var file in views)
-            {
-                fsMaster.DeleteFile(file);
-            }
+                fsViews.DeleteFile(file);
         }
 
         protected Stream CreateStream(string contents = null)

src/Umbraco.Tests/Persistence/Repositories/UserGroupRepositoryTest.cs

@@ -19,7 +19,7 @@ namespace Umbraco.Tests.Persistence.Repositories
     {
         private UserGroupRepository CreateRepository(IScopeProvider provider)
         {
-            return new UserGroupRepository((IScopeAccessor) provider, Core.Cache.CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+            return new UserGroupRepository((IScopeAccessor) provider, Core.Cache.CacheHelper.Disabled, Mock.Of<ILogger>());
         }
 
         [Test]
@@ -131,7 +131,7 @@ namespace Umbraco.Tests.Persistence.Repositories
                 
                 var id = userGroup.Id;
 
-                var repository2 = new UserGroupRepository((IScopeAccessor) provider, Core.Cache.CacheHelper.CreateDisabledCacheHelper(), Logger);
+                var repository2 = new UserGroupRepository((IScopeAccessor) provider, Core.Cache.CacheHelper.Disabled, Logger);
                 repository2.Delete(userGroup);
                 scope.Complete();
 

src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs

@@ -41,7 +41,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         private DocumentRepository CreateContentRepository(IScopeProvider provider, out IContentTypeRepository contentTypeRepository, out ITemplateRepository templateRepository)
         {
             var accessor = (IScopeAccessor) provider;
-            templateRepository = new TemplateRepository(accessor, CacheHelper, Logger, Mock.Of<ITemplatesSection>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>());
+            templateRepository = new TemplateRepository(accessor, CacheHelper, Logger, Mock.Of<ITemplatesSection>(), TestObjects.GetFileSystemsMock());
             var tagRepository = new TagRepository(accessor, CacheHelper, Logger);
             contentTypeRepository = new ContentTypeRepository(accessor, CacheHelper, Logger, templateRepository);
             var languageRepository = new LanguageRepository(accessor, CacheHelper, Logger);
@@ -52,14 +52,14 @@ namespace Umbraco.Tests.Persistence.Repositories
         private UserRepository CreateRepository(IScopeProvider provider)
         {
             var accessor = (IScopeAccessor) provider;
-            var repository = new UserRepository(accessor, CacheHelper.CreateDisabledCacheHelper(), Logger, Mappers, TestObjects.GetGlobalSettings());
+            var repository = new UserRepository(accessor, CacheHelper.Disabled, Logger, Mappers, TestObjects.GetGlobalSettings());
             return repository;
         }
 
         private UserGroupRepository CreateUserGroupRepository(IScopeProvider provider)
         {
             var accessor = (IScopeAccessor) provider;
-            return new UserGroupRepository(accessor, CacheHelper.CreateDisabledCacheHelper(), Logger);
+            return new UserGroupRepository(accessor, CacheHelper.Disabled, Logger);
         }
 
         [Test]
@@ -207,7 +207,7 @@ namespace Umbraco.Tests.Persistence.Repositories
                 
                 var id = user.Id;
 
-                var repository2 = new UserRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Logger, Mock.Of<IMapperCollection>(),TestObjects.GetGlobalSettings());
+                var repository2 = new UserRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger, Mock.Of<IMapperCollection>(),TestObjects.GetGlobalSettings());
 
                 repository2.Delete(user);
                 

src/Umbraco.Tests/Persistence/SyntaxProvider/SqlCeSyntaxProviderTests.cs

@@ -74,7 +74,7 @@ WHERE (([umbracoNode].[nodeObjectType] = @0))) x)".Replace(Environment.NewLine,
         [Test]
         public void Format_SqlServer_NonClusteredIndexDefinition_AddsNonClusteredDirective()
         {
-            var sqlSyntax = new SqlServerSyntaxProvider(new Lazy<IScopeProvider>(() => null));
+            var sqlSyntax = new SqlServerSyntaxProvider();
 
             var indexDefinition = CreateIndexDefinition();
             indexDefinition.IndexType = IndexTypes.NonClustered;
@@ -86,7 +86,7 @@ WHERE (([umbracoNode].[nodeObjectType] = @0))) x)".Replace(Environment.NewLine,
         [Test]
         public void Format_SqlServer_NonClusteredIndexDefinition_UsingIsClusteredFalse_AddsClusteredDirective()
         {
-            var sqlSyntax = new SqlServerSyntaxProvider(new Lazy<IScopeProvider>(() => null));
+            var sqlSyntax = new SqlServerSyntaxProvider();
 
             var indexDefinition = CreateIndexDefinition();
             indexDefinition.IndexType = IndexTypes.Clustered;
@@ -99,7 +99,7 @@ WHERE (([umbracoNode].[nodeObjectType] = @0))) x)".Replace(Environment.NewLine,
         public void CreateIndexBuilder_SqlServer_NonClustered_CreatesNonClusteredIndex()
         {
             var logger = Mock.Of<ILogger>();
-            var sqlSyntax = new SqlServerSyntaxProvider(new Lazy<IScopeProvider>(() => null));
+            var sqlSyntax = new SqlServerSyntaxProvider();
             var db = new TestDatabase(DatabaseType.SqlServer2005, sqlSyntax);
             var context = new MigrationContext(db, logger);
 
@@ -120,7 +120,7 @@ WHERE (([umbracoNode].[nodeObjectType] = @0))) x)".Replace(Environment.NewLine,
         public void CreateIndexBuilder_SqlServer_Unique_CreatesUniqueNonClusteredIndex()
         {
             var logger = Mock.Of<ILogger>();
-            var sqlSyntax = new SqlServerSyntaxProvider(new Lazy<IScopeProvider>(() => null));
+            var sqlSyntax = new SqlServerSyntaxProvider();
             var db = new TestDatabase(DatabaseType.SqlServer2005, sqlSyntax);
             var context = new MigrationContext(db, logger);
 
@@ -141,7 +141,7 @@ WHERE (([umbracoNode].[nodeObjectType] = @0))) x)".Replace(Environment.NewLine,
         public void CreateIndexBuilder_SqlServer_Unique_CreatesUniqueNonClusteredIndex_Multi_Columnn()
         {
             var logger = Mock.Of<ILogger>();
-            var sqlSyntax = new SqlServerSyntaxProvider(new Lazy<IScopeProvider>(() => null));
+            var sqlSyntax = new SqlServerSyntaxProvider();
             var db = new TestDatabase(DatabaseType.SqlServer2005, sqlSyntax);
             var context = new MigrationContext(db, logger);
 
@@ -162,7 +162,7 @@ WHERE (([umbracoNode].[nodeObjectType] = @0))) x)".Replace(Environment.NewLine,
         public void CreateIndexBuilder_SqlServer_Clustered_CreatesClusteredIndex()
         {
             var logger = Mock.Of<ILogger>();
-            var sqlSyntax = new SqlServerSyntaxProvider(new Lazy<IScopeProvider>(() => null));
+            var sqlSyntax = new SqlServerSyntaxProvider();
             var db = new TestDatabase(DatabaseType.SqlServer2005, sqlSyntax);
             var context = new MigrationContext(db, logger);
 

src/Umbraco.Tests/PropertyEditors/ImageCropperTest.cs

@@ -1,21 +1,23 @@
 using System;
 using System.Globalization;
-using LightInject;
 using Moq;
 using Newtonsoft.Json;
 using NUnit.Framework;
 using Newtonsoft.Json.Linq;
 using Umbraco.Core;
+using Umbraco.Core.Cache;
+using Umbraco.Core.Components;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Configuration;
 using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.IO;
-using Umbraco.Core.IO.MediaPathSchemes;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.PublishedContent;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.PropertyEditors.ValueConverters;
 using Umbraco.Core.Services;
+using Umbraco.Tests.Components;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Web.Models;
 using Umbraco.Web;
@@ -68,14 +70,18 @@ namespace Umbraco.Tests.PropertyEditors
         {
             try
             {
-                var container = new ServiceContainer();
-                container.ConfigureUmbracoCore();
-                container.RegisterCollectionBuilder<PropertyValueConverterCollectionBuilder>();
+                var container = RegisterFactory.Create();
+                var composition = new Composition(container, new TypeLoader(), Mock.Of<IProfilingLogger>(), ComponentTests.MockRuntimeState(RuntimeLevel.Run));
 
-                container.Register<ILogger, PerContainerLifetime>(f => Mock.Of<ILogger>());
-                container.Register<IContentSection, PerContainerLifetime>(f => Mock.Of<IContentSection>());
-                container.RegisterSingleton<IMediaPathScheme, OriginalMediaPathScheme>();
-                var mediaFileSystem = new MediaFileSystem(Mock.Of<IFileSystem>());
+                composition.WithCollectionBuilder<PropertyValueConverterCollectionBuilder>();
+
+                Current.Factory = composition.CreateFactory();
+
+                var logger = Mock.Of<ILogger>();
+                var scheme = Mock.Of<IMediaPathScheme>();
+                var config = Mock.Of<IContentSection>();
+
+                var mediaFileSystem = new MediaFileSystem(Mock.Of<IFileSystem>(), config, scheme, logger);
 
                 var dataTypeService = new TestObjects.TestDataTypeService(
                     new DataType(new ImageCropperPropertyEditor(Mock.Of<ILogger>(), mediaFileSystem, Mock.Of<IContentSection>(), Mock.Of<IDataTypeService>())) { Id = 1 });

src/Umbraco.Tests/PropertyEditors/PropertyEditorValueEditorTests.cs

@@ -1,14 +1,16 @@
 using System;
 using System.Threading;
-using LightInject;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
+using Umbraco.Core.Components;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.Services;
 using Umbraco.Core.Strings;
+using Umbraco.Tests.Components;
 using Umbraco.Tests.TestHelpers;
 
 namespace Umbraco.Tests.PropertyEditors
@@ -22,10 +24,13 @@ namespace Umbraco.Tests.PropertyEditors
             //normalize culture
             Thread.CurrentThread.CurrentUICulture = Thread.CurrentThread.CurrentCulture;
 
-            var container = new ServiceContainer();
-            container.ConfigureUmbracoCore();
-            container.Register<IShortStringHelper>(_
+            var register = RegisterFactory.Create();
+            var composition = new Composition(register, new TypeLoader(), Mock.Of<IProfilingLogger>(), ComponentTests.MockRuntimeState(RuntimeLevel.Run));
+
+            register.Register<IShortStringHelper>(_
                 => new DefaultShortStringHelper(new DefaultShortStringHelperConfig().WithDefault(SettingsForTests.GetDefaultUmbracoSettings())));
+
+            Current.Factory = composition.CreateFactory();
         }
 
         [TearDown]

src/Umbraco.Tests/Published/ConvertersTests.cs

@@ -1,15 +1,18 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using LightInject;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
+using Umbraco.Core.Cache;
+using Umbraco.Core.Components;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.PublishedContent;
 using Umbraco.Core.PropertyEditors;
+using Umbraco.Tests.Components;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Tests.TestHelpers.Stubs;
 using Umbraco.Web;
@@ -172,10 +175,11 @@ namespace Umbraco.Tests.Published
         public void SimpleConverter3Test()
         {
             Current.Reset();
-            var container = new ServiceContainer();
-            container.ConfigureUmbracoCore();
+            var register = RegisterFactory.Create();
 
-            Current.Container.RegisterCollectionBuilder<PropertyValueConverterCollectionBuilder>()
+            var composition = new Composition(register, new TypeLoader(), Mock.Of<IProfilingLogger>(), ComponentTests.MockRuntimeState(RuntimeLevel.Run));
+
+            composition.WithCollectionBuilder<PropertyValueConverterCollectionBuilder>()
                 .Append<SimpleConverter3A>()
                 .Append<SimpleConverter3B>();
 
@@ -184,7 +188,9 @@ namespace Umbraco.Tests.Published
                 typeof (PublishedSnapshotTestObjects.TestElementModel1), typeof (PublishedSnapshotTestObjects.TestElementModel2),
                 typeof (PublishedSnapshotTestObjects.TestContentModel1), typeof (PublishedSnapshotTestObjects.TestContentModel2),
             });
-            Current.Container.Register(f => factory);
+            register.Register(f => factory);
+
+            Current.Factory = composition.CreateFactory();
 
             var cacheMock = new Mock<IPublishedContentCache>();
             var cacheContent = new Dictionary<int, IPublishedContent>();
@@ -193,9 +199,9 @@ namespace Umbraco.Tests.Published
             publishedSnapshotMock.Setup(x => x.Content).Returns(cacheMock.Object);
             var publishedSnapshotAccessorMock = new Mock<IPublishedSnapshotAccessor>();
             publishedSnapshotAccessorMock.Setup(x => x.PublishedSnapshot).Returns(publishedSnapshotMock.Object);
-            Current.Container.Register(f => publishedSnapshotAccessorMock.Object);
+            register.Register(f => publishedSnapshotAccessorMock.Object);
 
-            var converters = Current.Container.GetInstance<PropertyValueConverterCollection>();
+            var converters = Current.Factory.GetInstance<PropertyValueConverterCollection>();
 
             var dataTypeService = new TestObjects.TestDataTypeService(
                 new DataType(new VoidEditor(Mock.Of<ILogger>())) { Id = 1 },

src/Umbraco.Tests/PublishedContent/NuCacheTests.cs

@@ -4,6 +4,7 @@ using System.Data;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
+using Umbraco.Core.Composing;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Events;
 using Umbraco.Core.Logging;
@@ -35,7 +36,7 @@ namespace Umbraco.Tests.PublishedContent
             // use any local db files, does not rely on any database) - and tests variations
 
             SettingsForTests.ConfigureSettings(SettingsForTests.GenerateMockUmbracoSettings());
-            var globalSettings = UmbracoConfig.For.GlobalSettings();
+            var globalSettings = Current.Config.Global();
 
             // create a content node kit
             var kit = new ContentNodeKit
@@ -101,7 +102,7 @@ namespace Umbraco.Tests.PublishedContent
             Mock.Get(dataTypeService).Setup(x => x.GetAll()).Returns(dataTypes);
 
             // create a service context
-            var serviceContext = new ServiceContext(
+            var serviceContext = ServiceContext.CreatePartial(
                 dataTypeService : dataTypeService,
                 memberTypeService: Mock.Of<IMemberTypeService>(),
                 memberService: Mock.Of<IMemberService>(),

src/Umbraco.Tests/PublishedContent/PublishedContentLanguageVariantTests.cs

@@ -2,13 +2,10 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
-using System.Reflection;
 using Moq;
 using NUnit.Framework;
-using Umbraco.Core.Composing;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.PublishedContent;
-using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.Services;
 using Umbraco.Tests.Testing;
 using Umbraco.Web;
@@ -23,12 +20,12 @@ namespace Umbraco.Tests.PublishedContent
         {
             base.Compose();
 
-            Container.RegisterSingleton(_ => GetServiceContext());
+            Composition.RegisterUnique(_ => GetServiceContext());
         }
 
         protected ServiceContext GetServiceContext()
         {
-            var serviceContext = TestObjects.GetServiceContextMock(Container);
+            var serviceContext = TestObjects.GetServiceContextMock(Factory);
             MockLocalizationService(serviceContext);
             return serviceContext;
         }

src/Umbraco.Tests/PublishedContent/PublishedContentMoreTests.cs

@@ -3,6 +3,7 @@ using System.Linq;
 using NUnit.Framework;
 using Umbraco.Core.Models.PublishedContent;
 using Umbraco.Web;
+using Umbraco.Core;
 using Umbraco.Tests.Testing;
 
 namespace Umbraco.Tests.PublishedContent

src/Umbraco.Tests/PublishedContent/PublishedContentSnapshotTestBase.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Linq;
-using System.Collections.ObjectModel;
 using System.Web.Routing;
 using Moq;
 using Umbraco.Core.Models.PublishedContent;
@@ -10,7 +9,8 @@ using Umbraco.Web.Routing;
 using Umbraco.Web.Security;
 using Umbraco.Core.Composing;
 using Current = Umbraco.Core.Composing.Current;
-using LightInject;
+using Umbraco.Core.Cache;
+using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.PropertyEditors;
@@ -37,12 +37,12 @@ namespace Umbraco.Tests.PublishedContent
         {
             base.Compose();
 
-            Container.RegisterSingleton<IPublishedModelFactory>(f => new PublishedModelFactory(f.GetInstance<TypeLoader>().GetTypes<PublishedContentModel>()));
+            Composition.RegisterUnique<IPublishedModelFactory>(f => new PublishedModelFactory(f.GetInstance<TypeLoader>().GetTypes<PublishedContentModel>()));
         }
 
-        protected override TypeLoader CreateTypeLoader(IServiceFactory f)
+        protected override TypeLoader CreateTypeLoader(IRuntimeCacheProvider runtimeCache, IGlobalSettings globalSettings, IProfilingLogger logger)
         {
-            var pluginManager = base.CreateTypeLoader(f);
+            var pluginManager = base.CreateTypeLoader(runtimeCache, globalSettings, logger);
 
             // this is so the model factory looks into the test assembly
             pluginManager.AssembliesToScan = pluginManager.AssembliesToScan

src/Umbraco.Tests/PublishedContent/PublishedContentTestBase.cs

@@ -1,14 +1,12 @@
 using Umbraco.Core;
-using Umbraco.Core.Composing;
 using Umbraco.Core.Models.PublishedContent;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.PropertyEditors.ValueConverters;
 using Umbraco.Tests.TestHelpers;
-using LightInject;
 using Moq;
+using Umbraco.Core.Composing;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
-using Umbraco.Core.Services;
 using Umbraco.Web.PropertyEditors;
 
 namespace Umbraco.Tests.PublishedContent
@@ -25,10 +23,8 @@ namespace Umbraco.Tests.PublishedContent
             // fixme - what about the if (PropertyValueConvertersResolver.HasCurrent == false) ??
             // can we risk double - registering and then, what happens?
 
-            var builder = Container.TryGetInstance<PropertyValueConverterCollectionBuilder>()
-                ?? Container.RegisterCollectionBuilder<PropertyValueConverterCollectionBuilder>();
-
-            builder.Clear()
+            Composition.WithCollectionBuilder<PropertyValueConverterCollectionBuilder>()
+                .Clear()
                 .Append<DatePickerValueConverter>()
                 .Append<TinyMceValueConverter>()
                 .Append<YesNoValueConverter>();
@@ -38,7 +34,7 @@ namespace Umbraco.Tests.PublishedContent
         {
             base.Initialize();
 
-            var converters = Container.GetInstance<PropertyValueConverterCollection>();
+            var converters = Factory.GetInstance<PropertyValueConverterCollection>();
 
             var dataTypeService = new TestObjects.TestDataTypeService(
                 new DataType(new RichTextPropertyEditor(Mock.Of<ILogger>())) { Id = 1 });

src/Umbraco.Tests/PublishedContent/PublishedContentTests.cs

@@ -9,8 +9,9 @@ using Umbraco.Core.PropertyEditors;
 using Umbraco.Web;
 using Umbraco.Web.PublishedCache;
 using Umbraco.Core.Composing;
-using LightInject;
 using Moq;
+using Umbraco.Core.Cache;
+using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Services;
@@ -32,9 +33,9 @@ namespace Umbraco.Tests.PublishedContent
         {
             base.Compose();
 
-            Container.RegisterSingleton<IPublishedModelFactory>(f => new PublishedModelFactory(f.GetInstance<TypeLoader>().GetTypes<PublishedContentModel>()));
-            Container.RegisterSingleton<IPublishedContentTypeFactory, PublishedContentTypeFactory>();
-            Container.RegisterSingleton<IPublishedValueFallback, PublishedValueFallback>();
+            Composition.RegisterUnique<IPublishedModelFactory>(f => new PublishedModelFactory(f.GetInstance<TypeLoader>().GetTypes<PublishedContentModel>()));
+            Composition.RegisterUnique<IPublishedContentTypeFactory, PublishedContentTypeFactory>();
+            Composition.RegisterUnique<IPublishedValueFallback, PublishedValueFallback>();
 
             var logger = Mock.Of<ILogger>();
             var dataTypeService = new TestObjects.TestDataTypeService(
@@ -44,14 +45,14 @@ namespace Umbraco.Tests.PublishedContent
                 new DataType(new IntegerPropertyEditor(logger)) { Id = 1003 },
                 new DataType(new TextboxPropertyEditor(logger)) { Id = 1004 },
                 new DataType(new MediaPickerPropertyEditor(logger)) { Id = 1005 });
-            Container.RegisterSingleton<IDataTypeService>(f => dataTypeService);
+            Composition.RegisterUnique<IDataTypeService>(f => dataTypeService);
         }
 
         protected override void Initialize()
         {
             base.Initialize();
 
-            var factory = Container.GetInstance<IPublishedContentTypeFactory>() as PublishedContentTypeFactory;
+            var factory = Factory.GetInstance<IPublishedContentTypeFactory>() as PublishedContentTypeFactory;
 
             // need to specify a custom callback for unit tests
             // AutoPublishedContentTypes generates properties automatically
@@ -72,9 +73,9 @@ namespace Umbraco.Tests.PublishedContent
             ContentTypesCache.GetPublishedContentTypeByAlias = alias => type;
         }
 
-        protected override TypeLoader CreateTypeLoader(IServiceFactory f)
+        protected override TypeLoader CreateTypeLoader(IRuntimeCacheProvider runtimeCache, IGlobalSettings globalSettings, IProfilingLogger logger)
         {
-            var pluginManager = base.CreateTypeLoader(f);
+            var pluginManager = base.CreateTypeLoader(runtimeCache, globalSettings, logger);
 
             // this is so the model factory looks into the test assembly
             pluginManager.AssembliesToScan = pluginManager.AssembliesToScan
@@ -453,7 +454,7 @@ namespace Umbraco.Tests.PublishedContent
         public void FirstChildAsT()
         {
             var doc = GetNode(1046); // has child nodes
-           
+
             var model = doc.FirstChild<Anything>(x => true); // predicate
 
             Assert.IsNotNull(model);
@@ -817,7 +818,7 @@ namespace Umbraco.Tests.PublishedContent
         [Test]
         public void FragmentProperty()
         {
-            var factory = Container.GetInstance<IPublishedContentTypeFactory>() as PublishedContentTypeFactory;
+            var factory = Factory.GetInstance<IPublishedContentTypeFactory>() as PublishedContentTypeFactory;
 
             var pt = factory.CreatePropertyType("detached", 1003);
             var ct = factory.CreateContentType(0, "alias", new[] { pt });
@@ -836,7 +837,7 @@ namespace Umbraco.Tests.PublishedContent
         [Test]
         public void Fragment2()
         {
-            var factory = Container.GetInstance<IPublishedContentTypeFactory>() as PublishedContentTypeFactory;
+            var factory = Factory.GetInstance<IPublishedContentTypeFactory>() as PublishedContentTypeFactory;
 
             var pt1 = factory.CreatePropertyType("legend", 1004);
             var pt2 = factory.CreatePropertyType("image", 1005);

src/Umbraco.Tests/PublishedContent/PublishedMediaTests.cs

@@ -1,7 +1,6 @@
 using System.Web;
 using System.Xml.Linq;
 using System.Xml.XPath;
-using Lucene.Net.Store;
 using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Core.Models;
@@ -20,9 +19,8 @@ using Umbraco.Core.Strings;
 using Umbraco.Examine;
 using Current = Umbraco.Web.Composing.Current;
 using Umbraco.Tests.Testing;
-using LightInject;
+using Umbraco.Core.Composing;
 using Umbraco.Core.Models.Membership;
-using Umbraco.Core.Services;
 using Umbraco.Core.PropertyEditors;
 
 namespace Umbraco.Tests.PublishedContent
@@ -42,7 +40,7 @@ namespace Umbraco.Tests.PublishedContent
         {
             base.Compose();
 
-            Container.GetInstance<UrlSegmentProviderCollectionBuilder>()
+            Composition.WithCollectionBuilder<UrlSegmentProviderCollectionBuilder>()
                 .Clear()
                 .Append<DefaultUrlSegmentProvider>();
         }
@@ -113,7 +111,7 @@ namespace Umbraco.Tests.PublishedContent
         [Test]
         public void Ensure_Children_Sorted_With_Examine()
         {
-            var rebuilder = IndexInitializer.GetMediaIndexRebuilder(Container.GetInstance<PropertyEditorCollection>(), IndexInitializer.GetMockMediaService());
+            var rebuilder = IndexInitializer.GetMediaIndexRebuilder(Factory.GetInstance<PropertyEditorCollection>(), IndexInitializer.GetMockMediaService());
 
             using (var luceneDir = new RandomIdRamDirectory())
             using (var indexer = IndexInitializer.GetUmbracoIndexer(ProfilingLogger, luceneDir,
@@ -142,7 +140,7 @@ namespace Umbraco.Tests.PublishedContent
         [Test]
         public void Do_Not_Find_In_Recycle_Bin()
         {
-            var rebuilder = IndexInitializer.GetMediaIndexRebuilder(Container.GetInstance<PropertyEditorCollection>(), IndexInitializer.GetMockMediaService());
+            var rebuilder = IndexInitializer.GetMediaIndexRebuilder(Factory.GetInstance<PropertyEditorCollection>(), IndexInitializer.GetMockMediaService());
 
             using (var luceneDir = new RandomIdRamDirectory())
             using (var indexer = IndexInitializer.GetUmbracoIndexer(ProfilingLogger, luceneDir,
@@ -190,7 +188,7 @@ namespace Umbraco.Tests.PublishedContent
         [Test]
         public void Children_With_Examine()
         {
-            var rebuilder = IndexInitializer.GetMediaIndexRebuilder(Container.GetInstance<PropertyEditorCollection>(), IndexInitializer.GetMockMediaService());
+            var rebuilder = IndexInitializer.GetMediaIndexRebuilder(Factory.GetInstance<PropertyEditorCollection>(), IndexInitializer.GetMockMediaService());
 
             using (var luceneDir = new RandomIdRamDirectory())
             using (var indexer = IndexInitializer.GetUmbracoIndexer(ProfilingLogger, luceneDir,
@@ -218,7 +216,7 @@ namespace Umbraco.Tests.PublishedContent
         [Test]
         public void Descendants_With_Examine()
         {
-            var rebuilder = IndexInitializer.GetMediaIndexRebuilder(Container.GetInstance<PropertyEditorCollection>(), IndexInitializer.GetMockMediaService());
+            var rebuilder = IndexInitializer.GetMediaIndexRebuilder(Factory.GetInstance<PropertyEditorCollection>(), IndexInitializer.GetMockMediaService());
 
             using (var luceneDir = new RandomIdRamDirectory())
             using (var indexer = IndexInitializer.GetUmbracoIndexer(ProfilingLogger, luceneDir,
@@ -246,7 +244,7 @@ namespace Umbraco.Tests.PublishedContent
         [Test]
         public void DescendantsOrSelf_With_Examine()
         {
-            var rebuilder = IndexInitializer.GetMediaIndexRebuilder(Container.GetInstance<PropertyEditorCollection>(), IndexInitializer.GetMockMediaService());
+            var rebuilder = IndexInitializer.GetMediaIndexRebuilder(Factory.GetInstance<PropertyEditorCollection>(), IndexInitializer.GetMockMediaService());
 
             using (var luceneDir = new RandomIdRamDirectory())
             using (var indexer = IndexInitializer.GetUmbracoIndexer(ProfilingLogger, luceneDir,
@@ -274,7 +272,7 @@ namespace Umbraco.Tests.PublishedContent
         [Test]
         public void Ancestors_With_Examine()
         {
-            var rebuilder = IndexInitializer.GetMediaIndexRebuilder(Container.GetInstance<PropertyEditorCollection>(), IndexInitializer.GetMockMediaService());
+            var rebuilder = IndexInitializer.GetMediaIndexRebuilder(Factory.GetInstance<PropertyEditorCollection>(), IndexInitializer.GetMockMediaService());
 
 
             using (var luceneDir = new RandomIdRamDirectory())
@@ -300,7 +298,7 @@ namespace Umbraco.Tests.PublishedContent
         [Test]
         public void AncestorsOrSelf_With_Examine()
         {
-            var rebuilder = IndexInitializer.GetMediaIndexRebuilder(Container.GetInstance<PropertyEditorCollection>(), IndexInitializer.GetMockMediaService());
+            var rebuilder = IndexInitializer.GetMediaIndexRebuilder(Factory.GetInstance<PropertyEditorCollection>(), IndexInitializer.GetMockMediaService());
 
             using (var luceneDir = new RandomIdRamDirectory())
             using (var indexer = IndexInitializer.GetUmbracoIndexer(ProfilingLogger, luceneDir,

src/Umbraco.Tests/Routing/ContentFinderByIdTests.cs

@@ -1,8 +1,9 @@
 using NUnit.Framework;
+using Umbraco.Core;
+using Umbraco.Core.Composing;
 using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Web.Routing;
-using LightInject;
 
 namespace Umbraco.Tests.Routing
 {
@@ -17,7 +18,7 @@ namespace Umbraco.Tests.Routing
             var umbracoContext = GetUmbracoContext(urlAsString);
             var publishedRouter = CreatePublishedRouter();
             var frequest = publishedRouter.CreateRequest(umbracoContext);
-            var lookup = new ContentFinderByIdPath(Container.GetInstance<IUmbracoSettingsSection>().WebRouting, Logger);
+            var lookup = new ContentFinderByIdPath(Factory.GetInstance<IUmbracoSettingsSection>().WebRouting, Logger);
 
 
             var result = lookup.TryFindContent(frequest);

src/Umbraco.Tests/Routing/ContentFinderByUrlAndTemplateTests.cs

@@ -1,12 +1,10 @@
 using Moq;
 using NUnit.Framework;
-using LightInject;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Web.Routing;
 using Umbraco.Core.Models;
 using Umbraco.Tests.Testing;
 using Current = Umbraco.Web.Composing.Current;
-using Umbraco.Core.Configuration.UmbracoSettings;
 
 namespace Umbraco.Tests.Routing
 {

src/Umbraco.Tests/Routing/ContentFinderByUrlTests.cs

@@ -2,6 +2,7 @@
 using System.Globalization;
 using Moq;
 using NUnit.Framework;
+using Umbraco.Core.Composing;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Models;
 using Umbraco.Tests.TestHelpers;
@@ -36,7 +37,7 @@ namespace Umbraco.Tests.Routing
             var frequest = publishedRouter.CreateRequest(umbracoContext);
             var lookup = new ContentFinderByUrl(Logger);
 
-            Assert.IsTrue(UmbracoConfig.For.GlobalSettings().HideTopLevelNodeFromPath);
+            Assert.IsTrue(Current.Config.Global().HideTopLevelNodeFromPath);
 
             // fixme debugging - going further down, the routes cache is NOT empty?!
             if (urlString == "/home/sub1")
@@ -66,13 +67,13 @@ namespace Umbraco.Tests.Routing
             var globalSettingsMock = Mock.Get(TestObjects.GetGlobalSettings()); //this will modify the IGlobalSettings instance stored in the container
             globalSettingsMock.Setup(x => x.HideTopLevelNodeFromPath).Returns(false);
             SettingsForTests.ConfigureSettings(globalSettingsMock.Object);
-            
+
             var umbracoContext = GetUmbracoContext(urlString, globalSettings:globalSettingsMock.Object);
             var publishedRouter = CreatePublishedRouter();
             var frequest = publishedRouter.CreateRequest(umbracoContext);
             var lookup = new ContentFinderByUrl(Logger);
 
-            Assert.IsFalse(UmbracoConfig.For.GlobalSettings().HideTopLevelNodeFromPath);
+            Assert.IsFalse(Current.Config.Global().HideTopLevelNodeFromPath);
 
             var result = lookup.TryFindContent(frequest);
 
@@ -97,7 +98,7 @@ namespace Umbraco.Tests.Routing
             var publishedRouter = CreatePublishedRouter();
             var frequest = publishedRouter.CreateRequest(umbracoContext);
             var lookup = new ContentFinderByUrl(Logger);
-            
+
             var result = lookup.TryFindContent(frequest);
 
             Assert.IsTrue(result);
@@ -156,7 +157,7 @@ namespace Umbraco.Tests.Routing
             var frequest = publishedRouter.CreateRequest(umbracoContext);
             frequest.Domain = new DomainAndUri(new Domain(1, "mysite/æøå", -1, CultureInfo.CurrentCulture, false), new Uri("http://mysite/æøå"));
             var lookup = new ContentFinderByUrl(Logger);
-            
+
             var result = lookup.TryFindContent(frequest);
 
             Assert.IsTrue(result);

src/Umbraco.Tests/Routing/ContentFinderByUrlWithDomainsTests.cs

@@ -129,7 +129,7 @@ namespace Umbraco.Tests.Routing
             SettingsForTests.ConfigureSettings(globalSettingsMock.Object);
             
             var umbracoContext = GetUmbracoContext(url, globalSettings:globalSettingsMock.Object);
-            var publishedRouter = CreatePublishedRouter(Container);
+            var publishedRouter = CreatePublishedRouter(Factory);
             var frequest = publishedRouter.CreateRequest(umbracoContext);
 
             // must lookup domain else lookup by url fails
@@ -172,7 +172,7 @@ namespace Umbraco.Tests.Routing
             SettingsForTests.ConfigureSettings(globalSettingsMock.Object);
 
             var umbracoContext = GetUmbracoContext(url, globalSettings:globalSettingsMock.Object);
-            var publishedRouter = CreatePublishedRouter(Container);
+            var publishedRouter = CreatePublishedRouter(Factory);
             var frequest = publishedRouter.CreateRequest(umbracoContext);
 
             // must lookup domain else lookup by url fails

src/Umbraco.Tests/Routing/DomainsAndCulturesTests.cs

@@ -1,9 +1,10 @@
-using System;
-using Moq;
+using Moq;
 using NUnit.Framework;
 using Umbraco.Core.Models;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Web.Routing;
+using Umbraco.Core;
+using Umbraco.Core.Composing;
 
 namespace Umbraco.Tests.Routing
 {
@@ -14,7 +15,7 @@ namespace Umbraco.Tests.Routing
         {
             base.Compose();
 
-            Container.Register<ISiteDomainHelper, SiteDomainHelper>();
+            Composition.Register<ISiteDomainHelper, SiteDomainHelper>();
         }
 
         private void SetDomains1()
@@ -269,7 +270,7 @@ namespace Umbraco.Tests.Routing
             SettingsForTests.ConfigureSettings(globalSettings.Object);
 
             var umbracoContext = GetUmbracoContext(inputUrl, globalSettings:globalSettings.Object);
-            var publishedRouter = CreatePublishedRouter(Container);
+            var publishedRouter = CreatePublishedRouter(Factory);
             var frequest = publishedRouter.CreateRequest(umbracoContext);
 
             // lookup domain
@@ -319,7 +320,7 @@ namespace Umbraco.Tests.Routing
             SettingsForTests.ConfigureSettings(globalSettings.Object);
 
             var umbracoContext = GetUmbracoContext(inputUrl, globalSettings:globalSettings.Object);
-            var publishedRouter = CreatePublishedRouter(Container);
+            var publishedRouter = CreatePublishedRouter(Factory);
             var frequest = publishedRouter.CreateRequest(umbracoContext);
 
             // lookup domain
@@ -374,7 +375,7 @@ namespace Umbraco.Tests.Routing
             globalSettings.Setup(x => x.HideTopLevelNodeFromPath).Returns(false);
             SettingsForTests.ConfigureSettings(globalSettings.Object);
             var umbracoContext = GetUmbracoContext(inputUrl, globalSettings:globalSettings.Object);
-            var publishedRouter = CreatePublishedRouter(Container);
+            var publishedRouter = CreatePublishedRouter(Factory);
             var frequest = publishedRouter.CreateRequest(umbracoContext);
 
             // lookup domain

src/Umbraco.Tests/Routing/GetContentUrlsTests.cs

@@ -59,7 +59,7 @@ namespace Umbraco.Tests.Routing
             content.Path = "-1,1046";
 
             var umbContext = GetUmbracoContext("http://localhost:8000");
-            var publishedRouter = CreatePublishedRouter(Container,
+            var publishedRouter = CreatePublishedRouter(Factory,
                 contentFinders: new ContentFinderCollection(new[] { new ContentFinderByUrl(Logger) }));
             var urls = content.GetContentUrls(publishedRouter,
                 umbContext,
@@ -79,10 +79,10 @@ namespace Umbraco.Tests.Routing
             content.Id = 1046; //fixme: we are using this ID only because it's built into the test XML published cache
             content.Path = "-1,1046";
             content.Published = true;
-            
+
             var umbContext = GetUmbracoContext("http://localhost:8000",
                 urlProviders: new []{ new DefaultUrlProvider(_umbracoSettings.RequestHandler, Logger, TestObjects.GetGlobalSettings(), new SiteDomainHelper()) });
-            var publishedRouter = CreatePublishedRouter(Container,
+            var publishedRouter = CreatePublishedRouter(Factory,
                 contentFinders:new ContentFinderCollection(new[]{new ContentFinderByUrl(Logger) }));
             var urls = content.GetContentUrls(publishedRouter,
                 umbContext,
@@ -112,7 +112,7 @@ namespace Umbraco.Tests.Routing
 
             var umbContext = GetUmbracoContext("http://localhost:8000",
                 urlProviders: new[] { new DefaultUrlProvider(_umbracoSettings.RequestHandler, Logger, TestObjects.GetGlobalSettings(), new SiteDomainHelper()) });
-            var publishedRouter = CreatePublishedRouter(Container,
+            var publishedRouter = CreatePublishedRouter(Factory,
                 contentFinders: new ContentFinderCollection(new[] { new ContentFinderByUrl(Logger) }));
             var urls = child.GetContentUrls(publishedRouter,
                 umbContext,

src/Umbraco.Tests/Routing/RenderRouteHandlerTests.cs

@@ -2,10 +2,10 @@
 using System.Linq;
 using System.Web.Mvc;
 using System.Web.Routing;
-using LightInject;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
+using Umbraco.Core.Cache;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Tests.TestHelpers;
@@ -13,11 +13,12 @@ using Umbraco.Tests.TestHelpers.Stubs;
 using Umbraco.Web;
 using Umbraco.Web.Models;
 using Umbraco.Web.Mvc;
-using Umbraco.Web.Routing;
 using Umbraco.Web.WebApi;
 using Umbraco.Core.Strings;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Configuration;
 using Umbraco.Core.Models.PublishedContent;
+using Umbraco.Core.Services;
 using Umbraco.Tests.PublishedContent;
 using Umbraco.Tests.Testing;
 using Umbraco.Tests.Testing.Objects.Accessors;
@@ -47,17 +48,8 @@ namespace Umbraco.Tests.Routing
                 : base(umbracoApplication)
             { }
 
-            public override void Boot(ServiceContainer container)
-            {
-                // do it before anything else - this is the only place where it's possible
-                var logger = Mock.Of<ILogger>();
-                container.RegisterInstance<ILogger>(logger);
-                var profiler = Mock.Of<IProfiler>();
-                container.RegisterInstance<IProfiler>(profiler);
-                container.RegisterInstance<ProfilingLogger>(new ProfilingLogger(logger, profiler));
-
-                base.Boot(container);
-            }
+            protected override ILogger GetLogger() => Mock.Of<ILogger>();
+            protected override IProfiler GetProfiler() => Mock.Of<IProfiler>();
         }
 
         protected override void Compose()
@@ -67,13 +59,13 @@ namespace Umbraco.Tests.Routing
             // set the default RenderMvcController
             Current.DefaultRenderMvcControllerType = typeof(RenderMvcController); // fixme WRONG!
 
-            var surfaceControllerTypes = new SurfaceControllerTypeCollection(Current.TypeLoader.GetSurfaceControllers());
-            Container.RegisterInstance(surfaceControllerTypes);
+            var surfaceControllerTypes = new SurfaceControllerTypeCollection(Composition.TypeLoader.GetSurfaceControllers());
+            Composition.RegisterUnique(surfaceControllerTypes);
 
-            var umbracoApiControllerTypes = new UmbracoApiControllerTypeCollection(Current.TypeLoader.GetUmbracoApiControllers());
-            Container.RegisterInstance(umbracoApiControllerTypes);
+            var umbracoApiControllerTypes = new UmbracoApiControllerTypeCollection(Composition.TypeLoader.GetUmbracoApiControllers());
+            Composition.RegisterUnique(umbracoApiControllerTypes);
 
-            Container.RegisterSingleton<IShortStringHelper>(_ => new DefaultShortStringHelper(SettingsForTests.GetDefaultUmbracoSettings()));
+            Composition.RegisterUnique<IShortStringHelper>(_ => new DefaultShortStringHelper(SettingsForTests.GetDefaultUmbracoSettings()));
         }
 
         public override void TearDown()
@@ -181,6 +173,11 @@ namespace Umbraco.Tests.Routing
         /// </summary>
         public class CustomDocumentController : RenderMvcController
         {
+            public CustomDocumentController(IGlobalSettings globalSettings, UmbracoContext umbracoContext, ServiceContext services, CacheHelper applicationCache, ILogger logger, IProfilingLogger profilingLogger)
+                : base(globalSettings, umbracoContext, services, applicationCache, logger, profilingLogger)
+            {
+            }
+
             public ActionResult HomePage(ContentModel model)
             {
                 return View();

src/Umbraco.Tests/Routing/UmbracoModuleTests.cs

@@ -4,13 +4,17 @@ using System.Threading;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
-using Umbraco.Core.Configuration;
+using Umbraco.Core.Composing;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Web;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Sync;
 using Umbraco.Core.Configuration.UmbracoSettings;
+using Umbraco.Core.Models.PublishedContent;
+using Umbraco.Core.Services;
+using Umbraco.Web.PublishedCache;
+using Umbraco.Web.Routing;
 
 namespace Umbraco.Tests.Routing
 {
@@ -18,23 +22,34 @@ namespace Umbraco.Tests.Routing
     [Apartment(ApartmentState.STA)]
     public class UmbracoModuleTests : BaseWebTest
     {
-        private UmbracoModule _module;
+        private UmbracoInjectedModule _module;
 
         public override void SetUp()
         {
             base.SetUp();
 
+            // fixme - be able to get the UmbracoModule from the container. any reason settings were from testobjects?
             //create the module
-            _module = new UmbracoModule
-            {
-                GlobalSettings = TestObjects.GetGlobalSettings(),
-                Logger = Mock.Of<ILogger>()
-            };
-            var runtime = new RuntimeState(_module.Logger, new Lazy<IServerRegistrar>(), new Lazy<MainDom>(), Mock.Of<IUmbracoSettingsSection>(), _module.GlobalSettings);
+            var logger = Mock.Of<ILogger>();
+            var globalSettings = TestObjects.GetGlobalSettings();
+            var runtime = new RuntimeState(logger, Mock.Of<IUmbracoSettingsSection>(), globalSettings,
+                new Lazy<IMainDom>(), new Lazy<IServerRegistrar>());
+
+            _module = new UmbracoInjectedModule
+            (
+                globalSettings,
+                Mock.Of<IUmbracoContextAccessor>(),
+                Factory.GetInstance<IPublishedSnapshotService>(),
+                Factory.GetInstance<IUserService>(),
+                new UrlProviderCollection(new IUrlProvider[0]),
+                runtime,
+                logger,
+                null, // fixme - PublishedRouter complexities...
+                Mock.Of<IVariationContextAccessor>()
+            );
 
-            _module.Runtime = runtime;
             runtime.Level = RuntimeLevel.Run;
-            
+
 
             //SettingsForTests.ReservedPaths = "~/umbraco,~/install/";
             //SettingsForTests.ReservedUrls = "~/config/splashes/booting.aspx,~/install/default.aspx,~/config/splashes/noNodes.aspx,~/VSEnterpriseHelper.axd";

src/Umbraco.Tests/Routing/UrlProviderTests.cs

@@ -4,6 +4,8 @@ using System.Globalization;
 using System.Linq;
 using Moq;
 using NUnit.Framework;
+using Umbraco.Core;
+using Umbraco.Core.Composing;
 using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.PublishedContent;
@@ -23,7 +25,7 @@ namespace Umbraco.Tests.Routing
         protected override void Compose()
         {
             base.Compose();
-            Container.Register<ISiteDomainHelper, SiteDomainHelper>();
+            Composition.Register<ISiteDomainHelper, SiteDomainHelper>();
         }
 
         private IUmbracoSettingsSection _umbracoSettings;

src/Umbraco.Tests/Routing/UrlRoutingTestBase.cs

@@ -2,6 +2,7 @@
 using System.Linq;
 using Moq;
 using NUnit.Framework;
+using Umbraco.Core;
 using Umbraco.Core.Composing;
 using Umbraco.Core.Models;
 using Umbraco.Core.Services;
@@ -33,13 +34,13 @@ namespace Umbraco.Tests.Routing
         {
             base.Compose();
 
-            Container.RegisterSingleton(_ => GetServiceContext());
+            Composition.RegisterUnique(_ => GetServiceContext());
         }
 
         protected ServiceContext GetServiceContext()
         {
             // get the mocked service context to get the mocked domain service
-            var serviceContext = TestObjects.GetServiceContextMock(Container);
+            var serviceContext = TestObjects.GetServiceContextMock(Factory);
 
             //setup mock domain service
             var domainService = Mock.Get(serviceContext.DomainService);

src/Umbraco.Tests/Routing/UrlsProviderWithDomainsTests.cs

@@ -3,12 +3,13 @@ using System.Collections.Generic;
 using System.Linq;
 using Moq;
 using NUnit.Framework;
+using Umbraco.Core;
+using Umbraco.Core.Composing;
 using Umbraco.Core.Models;
 using Umbraco.Core.Services;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Web.PublishedCache.XmlPublishedCache;
 using Umbraco.Web.Routing;
-using Umbraco.Core.Composing;
 
 namespace Umbraco.Tests.Routing
 {
@@ -19,8 +20,8 @@ namespace Umbraco.Tests.Routing
         {
             base.Compose();
 
-            Container.RegisterSingleton(_ => Mock.Of<IDomainService>());
-            Container.Register<ISiteDomainHelper, SiteDomainHelper>();
+            Composition.RegisterUnique(_ => Mock.Of<IDomainService>());
+            Composition.Register<ISiteDomainHelper, SiteDomainHelper>();
         }
 
         void SetDomains1()

src/Umbraco.Tests/Routing/UrlsWithNestedDomains.cs

@@ -1,12 +1,13 @@
 using System;
 using Moq;
 using NUnit.Framework;
+using Umbraco.Core;
+using Umbraco.Core.Composing;
 using Umbraco.Core.Models;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Web.PublishedCache.XmlPublishedCache;
 using Umbraco.Web.Routing;
 using Umbraco.Core.Services;
-using Umbraco.Core.Composing;
 
 namespace Umbraco.Tests.Routing
 {
@@ -21,8 +22,8 @@ namespace Umbraco.Tests.Routing
         protected override void Compose()
         {
             base.Compose();
-            Container.RegisterSingleton(_ => Mock.Of<IDomainService>());
-            Container.Register<ISiteDomainHelper, SiteDomainHelper>();
+            Composition.RegisterUnique(_ => Mock.Of<IDomainService>());
+            Composition.Register<ISiteDomainHelper, SiteDomainHelper>();
         }
 
         [Test]

src/Umbraco.Tests/Runtimes/CoreRuntimeTests.cs

@@ -1,16 +1,19 @@
 using System;
 using System.Collections.Generic;
+using System.Data;
 using System.Web.Hosting;
 using Examine;
-using LightInject;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Core.Components;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Events;
+using Umbraco.Core.Exceptions;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Runtime;
+using Umbraco.Core.Scoping;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Tests.TestHelpers.Stubs;
 using Umbraco.Web;
@@ -18,13 +21,18 @@ using Umbraco.Web;
 namespace Umbraco.Tests.Runtimes
 {
     [TestFixture]
-    [Ignore("cannot work until we refactor IUmbracoDatabaseFactory vs UmbracoDatabaseFactory")]
     public class CoreRuntimeTests
     {
         [SetUp]
         public void SetUp()
         {
             TestComponent.Reset();
+
+            // cannot boot runtime without some configuration
+            var umbracoSettings = SettingsForTests.GenerateMockUmbracoSettings();
+            var globalSettings = SettingsForTests.GenerateMockGlobalSettings();
+            SettingsForTests.ConfigureSettings(umbracoSettings);
+            SettingsForTests.ConfigureSettings(globalSettings);
         }
 
         public void TearDown()
@@ -39,12 +47,28 @@ namespace Umbraco.Tests.Runtimes
             {
                 app.HandleApplicationStart(app, new EventArgs());
 
+                var e = app.Runtime.State.BootFailedException;
+                var m = "";
+                switch (e)
+                {
+                    case null:
+                        m = "";
+                        break;
+                    case BootFailedException bfe when bfe.InnerException != null:
+                        m = "BootFailed: " + bfe.InnerException.GetType() + " " + bfe.InnerException.Message + " " + bfe.InnerException.StackTrace;
+                        break;
+                    default:
+                        m = e.GetType() + " " + e.Message + " " + e.StackTrace;
+                        break;
+                }
+
+                Assert.AreNotEqual(RuntimeLevel.BootFailed, app.Runtime.State.Level, m);
+                Assert.IsTrue(TestComposer.Ctored);
+                Assert.IsTrue(TestComposer.Composed);
                 Assert.IsTrue(TestComponent.Ctored);
-                Assert.IsTrue(TestComponent.Composed);
-                Assert.IsTrue(TestComponent.Initialized1);
-                Assert.IsTrue(TestComponent.Initialized2);
                 Assert.IsNotNull(TestComponent.ProfilingLogger);
-                Assert.IsInstanceOf<DebugDiagnosticsLogger>(TestComponent.ProfilingLogger.Logger);
+                Assert.IsInstanceOf<ProfilingLogger>(TestComponent.ProfilingLogger);
+                Assert.IsInstanceOf<DebugDiagnosticsLogger>(((ProfilingLogger) TestComponent.ProfilingLogger).Logger);
 
                 // note: components are NOT disposed after boot
 
@@ -58,40 +82,23 @@ namespace Umbraco.Tests.Runtimes
         // test application
         public class TestUmbracoApplication : UmbracoApplicationBase
         {
+            public IRuntime Runtime { get; private set; }
+
             protected override IRuntime GetRuntime()
             {
-                return new TestRuntime();
+                return Runtime = new TestRuntime();
             }
         }
 
         // test runtime
         public class TestRuntime : CoreRuntime
         {
-            // the application's logger is created by the application
-            // through GetLogger, that custom application can override
-            protected override ILogger GetLogger()
-            {
-                //return Mock.Of<ILogger>();
-                return new DebugDiagnosticsLogger();
-            }
-
-            public override void Compose(ServiceContainer container)
-            {
-                base.Compose(container);
-
-                // the application's profiler and profiling logger are
-                // registered by CoreRuntime.Compose() but can be
-                // overriden afterwards - they haven't been resolved yet
-                container.RegisterSingleton<IProfiler>(_ => new TestProfiler());
-                container.RegisterSingleton(factory => new ProfilingLogger(factory.GetInstance<ILogger>(), factory.GetInstance<IProfiler>()));
-
-                // must override the database factory
-                container.RegisterSingleton(_ => GetDatabaseFactory());
-            }
+            protected override ILogger GetLogger() => new DebugDiagnosticsLogger();
+            protected override IProfiler GetProfiler() => new TestProfiler();
 
             // must override the database factory
             // else BootFailedException because U cannot connect to the configured db
-            private static IUmbracoDatabaseFactory GetDatabaseFactory()
+            protected internal override IUmbracoDatabaseFactory GetDatabaseFactory()
             {
                 var mock = new Mock<IUmbracoDatabaseFactory>();
                 mock.Setup(x => x.Configured).Returns(true);
@@ -99,19 +106,43 @@ namespace Umbraco.Tests.Runtimes
                 return mock.Object;
             }
 
+            // fixme so how the f* should we do it now?
+            /*
             // pretend we have the proper migration
             // else BootFailedException because our mock IUmbracoDatabaseFactory does not provide databases
-            protected override bool EnsureUmbracoUpgradeState(IUmbracoDatabaseFactory databaseFactory, ILogger logger)
+            protected override bool EnsureUmbracoUpgradeState(IUmbracoDatabaseFactory databaseFactory)
             {
                 return true;
             }
+            */
 
-            private MainDom _mainDom;
-
-            public override void Boot(ServiceContainer container)
+            // because we don't even have the core runtime component,
+            // there are a few required stuff that we need to compose
+            public override void Compose(Composition composition)
             {
-                base.Boot(container);
-                _mainDom = container.GetInstance<MainDom>();
+                base.Compose(composition);
+
+                var scopeProvider = Mock.Of<IScopeProvider>();
+                Mock.Get(scopeProvider)
+                    .Setup(x => x.CreateScope(
+                        It.IsAny<IsolationLevel>(),
+                        It.IsAny<RepositoryCacheMode>(),
+                        It.IsAny<IEventDispatcher>(),
+                        It.IsAny<bool?>(),
+                        It.IsAny<bool>(),
+                        It.IsAny<bool>()))
+                    .Returns(Mock.Of<IScope>());
+
+                composition.RegisterUnique(scopeProvider);
+            }
+
+            private IMainDom _mainDom;
+
+            public override IFactory Boot(IRegister container)
+            {
+                var factory = base.Boot(container);
+                _mainDom = factory.GetInstance<IMainDom>();
+                return factory;
             }
 
             public override void Terminate()
@@ -123,62 +154,65 @@ namespace Umbraco.Tests.Runtimes
             // runs with only one single component
             // UmbracoCoreComponent will be force-added too
             // and that's it
-            protected override IEnumerable<Type> GetComponentTypes()
+            protected override IEnumerable<Type> GetComposerTypes(TypeLoader typeLoader)
             {
-                return new[] { typeof(TestComponent) };
+                return new[] { typeof(TestComposer) };
             }
         }
 
 
-        public class TestComponent : UmbracoComponentBase
+        public class TestComposer : IComposer
         {
             // test flags
             public static bool Ctored;
             public static bool Composed;
-            public static bool Initialized1;
-            public static bool Initialized2;
-            public static bool Terminated;
-            public static ProfilingLogger ProfilingLogger;
 
             public static void Reset()
             {
-                Ctored = Composed = Initialized1 = Initialized2 = Terminated = false;
-                ProfilingLogger = null;
+                Ctored = Composed = false;
             }
 
-            public TestComponent()
+            public TestComposer()
             {
                 Ctored = true;
             }
 
-            public override void Compose(Composition composition)
+            public void Compose(Composition composition)
             {
-                base.Compose(composition);
-
-                composition.Container.Register(factory => SettingsForTests.GetDefaultUmbracoSettings());
-                composition.Container.RegisterSingleton<IExamineManager, TestExamineManager>();
+                composition.Register(factory => SettingsForTests.GetDefaultUmbracoSettings());
+                composition.RegisterUnique<IExamineManager, TestExamineManager>();
+                composition.Components().Append<TestComponent>();
 
                 Composed = true;
             }
+        }
 
-            public void Initialize()
+        public class TestComponent : IComponent, IDisposable
+        {
+            // test flags
+            public static bool Ctored;
+            public static bool Initialized1;
+            public static bool Initialized2;
+            public static bool Terminated;
+            public static IProfilingLogger ProfilingLogger;
+
+            public bool Disposed;
+
+            public static void Reset()
             {
-                Initialized1 = true;
+                Ctored = Initialized1 = Initialized2 = Terminated = false;
+                ProfilingLogger = null;
             }
 
-            public void Initialize(ILogger logger)
-            {
-                Initialized2 = true;
-            }
-
-            public void Initialize(ProfilingLogger proflog)
+            public TestComponent(IProfilingLogger proflog)
             {
+                Ctored = true;
                 ProfilingLogger = proflog;
             }
 
-            public override void Terminate()
+            public void Dispose()
             {
-                base.Terminate();
+                Disposed = true;
                 Terminated = true;
             }
         }

src/Umbraco.Tests/Runtimes/StandaloneTests.cs

@@ -0,0 +1,399 @@
+using System;
+using System.Configuration;
+using System.Data.SqlServerCe;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Web;
+using Examine;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Core;
+using Umbraco.Core.Cache;
+using Umbraco.Core.Components;
+using Umbraco.Core.Composing;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.IO;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Migrations.Install;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.PublishedContent;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.Mappers;
+using Umbraco.Core.Runtime;
+using Umbraco.Core.Scoping;
+using Umbraco.Core.Services;
+using Umbraco.Core.Sync;
+using Umbraco.Tests.Composing;
+using Umbraco.Tests.TestHelpers;
+using Umbraco.Tests.Testing.Objects.Accessors;
+using Umbraco.Web;
+using Umbraco.Web.Cache;
+using Umbraco.Web.PublishedCache;
+using Umbraco.Web.Routing;
+using Umbraco.Web.Runtime;
+using File = System.IO.File;
+
+namespace Umbraco.Tests.Runtimes
+{
+    [TestFixture]
+    public class StandaloneTests
+    {
+        [Test]
+        [Explicit("This test must be run manually")]
+        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["umbracoConfigurationStatus"] = "";
+            // 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 CacheHelper(); // fixme has HttpRuntime stuff?
+            var databaseFactory = new UmbracoDatabaseFactory(logger, new Lazy<IMapperCollection>(() => factory.GetInstance<IMapperCollection>()));
+            var typeLoader = new TypeLoader(appCaches.RuntimeCache, LocalTempStorage.Default, 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(WebRuntimeComposer)); // exclude web runtime
+            var composers = new Composers(composition, composerTypes, 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.RegisterUnique(f => new DistributedCache());
+            composition.WithCollectionBuilder<UrlProviderCollectionBuilder>().Append<DefaultUrlProvider>();
+            composition.RegisterUnique<IDistributedCacheBinder, DistributedCacheBinder>();
+            composition.RegisterUnique<IExamineManager>(f => ExamineManager.Instance);
+
+            // initialize some components only/individually
+            composition.WithCollectionBuilder<ComponentCollectionBuilder>()
+                .Clear()
+                .Append<DistributedCacheBinderComponent>();
+
+            // 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 = 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
+                using (var engine = new SqlCeEngine("Data Source=|DataDirectory|\\Umbraco.sdf;Flush Interval=1;"))
+                {
+                    engine.CreateDatabase();
+                }
+
+                //var databaseBuilder = factory.GetInstance<DatabaseBuilder>();
+                //databaseFactory.Configure(DatabaseBuilder.EmbeddedDatabaseConnectionString, Constants.DbProviderNames.SqlCe);
+                //databaseBuilder.CreateDatabaseSchemaAndData();
+
+                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;
+
+            var globalSettings = SettingsForTests.GetDefaultGlobalSettings();
+            SettingsForTests.ConfigureSettings(globalSettings);
+            var umbracoSettings = SettingsForTests.GetDefaultUmbracoSettings();
+            SettingsForTests.ConfigureSettings(umbracoSettings);
+
+            // 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 withUmbracoContext = UmbracoContext.EnsureContext(httpContext);
+            var umbracoContext = Umbraco.Web.Composing.Current.UmbracoContext;
+
+            // assert that there is no published document
+            var pcontent = umbracoContext.ContentCache.GetById(content.Id);
+            Assert.IsNull(pcontent);
+
+            // but a draft document
+            pcontent = umbracoContext.ContentCache.GetById(true, content.Id);
+            Assert.IsNotNull(pcontent);
+            Assert.AreEqual("test", pcontent.Name);
+            Assert.IsTrue(pcontent.IsDraft());
+
+            // no published url
+            Assert.AreEqual("#", pcontent.GetUrl());
+
+            // 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.ContentCache.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.GetUrl());
+
+            // and also an updated draft document
+            pcontent = umbracoContext.ContentCache.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.GetUrl());
+
+            withUmbracoContext.Dispose();
+            mainDom.Stop();
+            components.Terminate();
+
+            // exit!
+        }
+
+        [Test]
+        [Explicit("This test must be run manually")]
+        public void ValidateComposition()
+        {
+            // this is almost what CoreRuntime does, without
+            // - managing MainDom
+            // - configuring for unhandled exceptions, assembly resolution, application root path
+            // - testing for database, and for upgrades (runtime level)
+            // - assigning the factory to Current.Factory
+
+            // create the very basic and essential things we need
+            var logger = new ConsoleLogger();
+            var profiler = Mock.Of<IProfiler>();
+            var profilingLogger = new ProfilingLogger(logger, profiler);
+            var appCaches = CacheHelper.Disabled;
+            var databaseFactory = Mock.Of<IUmbracoDatabaseFactory>();
+            var typeLoader = new TypeLoader(appCaches.RuntimeCache, LocalTempStorage.Default, profilingLogger);
+            var runtimeState = Mock.Of<IRuntimeState>();
+            Mock.Get(runtimeState).Setup(x => x.Level).Returns(RuntimeLevel.Run);
+            var mainDom = Mock.Of<IMainDom>();
+            Mock.Get(mainDom).Setup(x => x.IsMainDom).Returns(true);
+
+            // 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);
+
+            // get the components
+            // all of them?
+            var composerTypes = typeLoader.GetTypes<IComposer>();
+            // filtered?
+            //var componentTypes = typeLoader.GetTypes<IUmbracoComponent>()
+            //    .Where(x => !x.FullName.StartsWith("Umbraco.Web"));
+            // single?
+            //var componentTypes = new[] { typeof(CoreRuntimeComponent) };
+            var composers = new Composers(composition, composerTypes, profilingLogger);
+
+            // get components to compose themselves
+            composers.Compose();
+
+            // create the factory
+            var factory = composition.CreateFactory();
+
+            // at that point Umbraco is fully composed
+            // but nothing is initialized (no maindom, nothing - beware!)
+            // to actually *run* Umbraco standalone, better use a StandaloneRuntime
+            // that would inherit from CoreRuntime and ensure everything starts
+
+            // get components to initialize themselves
+            //components.Initialize(factory);
+
+            // and then, validate
+            var lightInjectContainer = (LightInject.ServiceContainer) factory.Concrete;
+            var results = lightInjectContainer.Validate().ToList();
+            foreach (var resultGroup in results.GroupBy(x => x.Severity).OrderBy(x => x.Key))
+            {
+                Console.WriteLine($"{resultGroup.Key}: {resultGroup.Count()}");
+            }
+
+            foreach (var resultGroup in results.GroupBy(x => x.Severity).OrderBy(x => x.Key))
+            foreach (var result in resultGroup)
+            {
+                Console.WriteLine();
+                Console.Write(ToText(result));
+            }
+
+            Assert.AreEqual(0, results.Count);
+        }
+
+        private static string ToText(ValidationResult result)
+        {
+            var text = new StringBuilder();
+
+            text.AppendLine($"{result.Severity}: {WordWrap(result.Message, 120)}");
+            var target = result.ValidationTarget;
+            text.Append("\tsvce: ");
+            text.Append(target.ServiceName);
+            text.Append(target.DeclaringService.ServiceType);
+            if (!target.DeclaringService.ServiceName.IsNullOrWhiteSpace())
+            {
+                text.Append(" '");
+                text.Append(target.DeclaringService.ServiceName);
+                text.Append("'");
+            }
+
+            text.Append("     (");
+            if (target.DeclaringService.Lifetime == null)
+                text.Append("Transient");
+            else
+                text.Append(target.DeclaringService.Lifetime.ToString().TrimStart("LightInject.").TrimEnd("Lifetime"));
+            text.AppendLine(")");
+            text.Append("\timpl: ");
+            text.Append(target.DeclaringService.ImplementingType);
+            text.AppendLine();
+            text.Append("\tparm: ");
+            text.Append(target.Parameter);
+            text.AppendLine();
+
+            return text.ToString();
+        }
+
+        private static string WordWrap(string text, int width)
+        {
+            int pos, next;
+            var sb = new StringBuilder();
+            var nl = Environment.NewLine;
+
+            // Lucidity check
+            if (width < 1)
+                return text;
+
+            // Parse each line of text
+            for (pos = 0; pos < text.Length; pos = next)
+            {
+                // Find end of line
+                var eol = text.IndexOf(nl, pos, StringComparison.Ordinal);
+
+                if (eol == -1)
+                    next = eol = text.Length;
+                else
+                    next = eol + nl.Length;
+
+                // Copy this line of text, breaking into smaller lines as needed
+                if (eol > pos)
+                {
+                    do
+                    {
+                        var len = eol - pos;
+
+                        if (len > width)
+                            len = BreakLine(text, pos, width);
+
+                        if (pos > 0)
+                            sb.Append("\t\t");
+                        sb.Append(text, pos, len);
+                        sb.Append(nl);
+
+                        // Trim whitespace following break
+                        pos += len;
+
+                        while (pos < eol && char.IsWhiteSpace(text[pos]))
+                            pos++;
+
+                    } while (eol > pos);
+                }
+                else sb.Append(nl); // Empty line
+            }
+
+            return sb.ToString();
+        }
+
+        private static int BreakLine(string text, int pos, int max)
+        {
+            // Find last whitespace in line
+            var i = max - 1;
+            while (i >= 0 && !char.IsWhiteSpace(text[pos + i]))
+                i--;
+            if (i < 0)
+                return max; // No whitespace found; break at maximum length
+            // Find start of whitespace
+            while (i >= 0 && char.IsWhiteSpace(text[pos + i]))
+                i--;
+            // Return length of text before whitespace
+            return i + 1;
+        }
+    }
+}

src/Umbraco.Tests/Runtimes/WebRuntimeComponentTests.cs

@@ -2,14 +2,13 @@
 using System.Web.Mvc;
 using NUnit.Framework;
 using Umbraco.Core.Profiling;
-using Umbraco.Web;
 using Umbraco.Web.Mvc;
 using Umbraco.Web.Runtime;
 
 namespace Umbraco.Tests.Runtimes
 {
     [TestFixture]
-    public class WebRuntimeTests
+    public class WebRuntimeComponentTests
     {
         [Test]
         public void WrapViewEngines_HasEngines_WrapsAll()
@@ -43,7 +42,6 @@ namespace Umbraco.Tests.Runtimes
             Assert.That(((ProfilingViewEngine)engines[1]).Inner, Is.InstanceOf<PluginViewEngine>());
         }
 
-
         [Test]
         public void WrapViewEngines_HasProfiledEngine_AddsSameInstance()
         {
@@ -61,10 +59,7 @@ namespace Umbraco.Tests.Runtimes
         [Test]
         public void WrapViewEngines_CollectionIsNull_DoesNotThrow()
         {
-            IList<IViewEngine> engines = null;
-            Assert.DoesNotThrow(() => WebRuntimeComponent.WrapViewEngines(engines));
-            Assert.That(engines, Is.Null);
+            Assert.DoesNotThrow(() => WebRuntimeComponent.WrapViewEngines(null));
         }
-
     }
 }

src/Umbraco.Tests/Scheduling/BackgroundTaskRunnerTests.cs

@@ -13,6 +13,7 @@ namespace Umbraco.Tests.Scheduling
 {
     [TestFixture]
     [Timeout(30000)]
+    [Category("Slow")]
     public class BackgroundTaskRunnerTests
     {
         private ILogger _logger;

src/Umbraco.Tests/Scoping/ScopeEventDispatcherTests.cs

@@ -1,10 +1,10 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
-using LightInject;
 using Moq;
 using NUnit.Framework;
-using Umbraco.Core.Collections;
+using Umbraco.Core;
+using Umbraco.Core.Cache;
+using Umbraco.Core.Components;
 using Umbraco.Core.Events;
 using Umbraco.Core.Models;
 using Umbraco.Core.IO;
@@ -13,8 +13,10 @@ using Umbraco.Core.Scoping;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Tests.TestHelpers.Entities;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Configuration;
 using Umbraco.Core.Persistence.Mappers;
 using Umbraco.Core.Services;
+using Umbraco.Tests.Components;
 
 namespace Umbraco.Tests.Scoping
 {
@@ -31,12 +33,17 @@ namespace Umbraco.Tests.Scoping
             DoThing2 = null;
             DoThing3 = null;
 
-            Current.Container = new ServiceContainer();
+            var register = RegisterFactory.Create();
 
-            _testObjects = new TestObjects(Current.Container);
-            Current.Container.RegisterSingleton(f => Current.Container);
-            Current.Container.RegisterSingleton(factory => new FileSystems(factory.TryGetInstance<ILogger>()));
-            Current.Container.RegisterCollectionBuilder<MapperCollectionBuilder>();
+            var composition = new Composition(register, new TypeLoader(), Mock.Of<IProfilingLogger>(), ComponentTests.MockRuntimeState(RuntimeLevel.Run));
+
+            _testObjects = new TestObjects(register);
+
+            composition.RegisterUnique(factory => new FileSystems(factory, factory.TryGetInstance<ILogger>()));
+            composition.WithCollectionBuilder<MapperCollectionBuilder>();
+
+            Current.Reset();
+            Current.Factory = composition.CreateFactory();
 
             SettingsForTests.Reset(); // ensure we have configuration
         }

src/Umbraco.Tests/Scoping/ScopeFileSystemsTests.cs

@@ -4,8 +4,8 @@ using System.Text;
 using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Composing.Composers;
 using Umbraco.Core.IO;
-using Umbraco.Core.Scoping;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Tests.Testing;
 
@@ -23,11 +23,21 @@ namespace Umbraco.Tests.Scoping
             ClearFiles();
         }
 
+        protected override void ComposeApplication(bool withApplication)
+        {
+            base.ComposeApplication(withApplication);
+
+            if (!withApplication) return;
+
+            // re-register with actual media fs
+            Composition.ComposeFileSystems();
+        }
+
         public override void TearDown()
         {
             base.TearDown();
             SafeCallContext.Clear();
-            ShadowFileSystems.ResetId();
+            FileSystems.ResetShadowId();
             ClearFiles();
         }
 
@@ -35,7 +45,7 @@ namespace Umbraco.Tests.Scoping
         {
             TestHelper.DeleteDirectory(IOHelper.MapPath("media"));
             TestHelper.DeleteDirectory(IOHelper.MapPath("FileSysTests"));
-            TestHelper.DeleteDirectory(IOHelper.MapPath("App_Data"));
+            TestHelper.DeleteDirectory(IOHelper.MapPath("App_Data/TEMP/ShadowFs"));
         }
 
         [TestCase(true)]
@@ -43,7 +53,7 @@ namespace Umbraco.Tests.Scoping
         public void CreateMediaTest(bool complete)
         {
             var physMediaFileSystem = new PhysicalFileSystem(IOHelper.MapPath("media"), "ignore");
-            var mediaFileSystem = Current.FileSystems.MediaFileSystem;
+            var mediaFileSystem = Current.MediaFileSystem;
 
             Assert.IsFalse(physMediaFileSystem.FileExists("f1.txt"));
 
@@ -62,12 +72,12 @@ namespace Umbraco.Tests.Scoping
 
             if (complete)
             {
-                Assert.IsTrue(Current.FileSystems.MediaFileSystem.FileExists("f1.txt"));
+                Assert.IsTrue(Current.MediaFileSystem.FileExists("f1.txt"));
                 Assert.IsTrue(physMediaFileSystem.FileExists("f1.txt"));
             }
             else
             {
-                Assert.IsFalse(Current.FileSystems.MediaFileSystem.FileExists("f1.txt"));
+                Assert.IsFalse(Current.MediaFileSystem.FileExists("f1.txt"));
                 Assert.IsFalse(physMediaFileSystem.FileExists("f1.txt"));
             }
         }
@@ -76,7 +86,7 @@ namespace Umbraco.Tests.Scoping
         public void MultiThread()
         {
             var physMediaFileSystem = new PhysicalFileSystem(IOHelper.MapPath("media"), "ignore");
-            var mediaFileSystem = Current.FileSystems.MediaFileSystem;
+            var mediaFileSystem = Current.MediaFileSystem;
 
             var scopeProvider = ScopeProvider;
             using (var scope = scopeProvider.CreateScope(scopeFileSystems: true))

src/Umbraco.Tests/Scoping/ScopedNuCacheTests.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Web.Routing;
-using LightInject;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
@@ -15,7 +14,6 @@ using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.PublishedContent;
 using Umbraco.Core.Persistence.Repositories;
-using Umbraco.Core.Persistence.Repositories.Implement;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.Services;
 using Umbraco.Core.Services.Implement;
@@ -47,10 +45,10 @@ namespace Umbraco.Tests.Scoping
             // but then, it requires a lot of plumbing ;(
             // fixme - and we cannot inject a DistributedCache yet
             // so doing all this mess
-            Container.RegisterSingleton<IServerMessenger, ScopedXmlTests.LocalServerMessenger>();
-            Container.RegisterSingleton(f => Mock.Of<IServerRegistrar>());
-            Container.RegisterCollectionBuilder<CacheRefresherCollectionBuilder>()
-                .Add(f => f.TryGetInstance<TypeLoader>().GetCacheRefreshers());
+            Composition.RegisterUnique<IServerMessenger, ScopedXmlTests.LocalServerMessenger>();
+            Composition.RegisterUnique(f => Mock.Of<IServerRegistrar>());
+            Composition.WithCollectionBuilder<CacheRefresherCollectionBuilder>()
+                .Add(() => Composition.TypeLoader.GetCacheRefreshers());
         }
 
         public override void TearDown()
@@ -97,7 +95,7 @@ namespace Umbraco.Tests.Scoping
                 documentRepository, mediaRepository, memberRepository,
                 DefaultCultureAccessor,
                 new DatabaseDataSource(),
-                Container.GetInstance<IGlobalSettings>(), new SiteDomainHelper());
+                Factory.GetInstance<IGlobalSettings>(), new SiteDomainHelper());
         }
 
         protected UmbracoContext GetUmbracoContextNu(string url, int templateId = 1234, RouteData routeData = null, bool setSingleton = false, IUmbracoSettingsSection umbracoSettings = null, IEnumerable<IUrlProvider> urlProviders = null)

src/Umbraco.Tests/Scoping/ScopedRepositoryTests.cs

@@ -10,7 +10,6 @@ using Umbraco.Core.Scoping;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Tests.Testing;
 using Umbraco.Web.Cache;
-using LightInject;
 using Moq;
 using Umbraco.Core.Events;
 using Umbraco.Core.Logging;
@@ -32,22 +31,20 @@ namespace Umbraco.Tests.Scoping
             // but then, it requires a lot of plumbing ;(
             // fixme - and we cannot inject a DistributedCache yet
             // so doing all this mess
-            Container.RegisterSingleton<IServerMessenger, LocalServerMessenger>();
-            Container.RegisterSingleton(f => Mock.Of<IServerRegistrar>());
-            Container.RegisterCollectionBuilder<CacheRefresherCollectionBuilder>()
-                .Add(f => f.TryGetInstance<TypeLoader>().GetCacheRefreshers());
+            Composition.RegisterUnique<IServerMessenger, LocalServerMessenger>();
+            Composition.RegisterUnique(f => Mock.Of<IServerRegistrar>());
+            Composition.WithCollectionBuilder<CacheRefresherCollectionBuilder>()
+                .Add(() => Composition.TypeLoader.GetCacheRefreshers());
         }
 
-        protected override void ComposeCacheHelper()
+        protected override CacheHelper GetCacheHelper()
         {
             // this is what's created core web runtime
-            var cacheHelper = new CacheHelper(
+            return new CacheHelper(
                 new DeepCloneRuntimeCacheProvider(new ObjectCacheRuntimeCacheProvider()),
                 new StaticCacheProvider(),
                 NullCacheProvider.Instance,
                 new IsolatedRuntimeCache(type => new DeepCloneRuntimeCacheProvider(new ObjectCacheRuntimeCacheProvider())));
-            Container.RegisterSingleton(f => cacheHelper);
-            Container.RegisterSingleton(f => f.GetInstance<CacheHelper>().RuntimeCache);
         }
 
         [TearDown]

src/Umbraco.Tests/Scoping/ScopedXmlTests.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.Xml;
 using Moq;
 using NUnit.Framework;
-using LightInject;
 using Umbraco.Core.Cache;
 using Umbraco.Core.Composing;
 using Umbraco.Core.Events;
@@ -34,10 +33,10 @@ namespace Umbraco.Tests.Scoping
             // but then, it requires a lot of plumbing ;(
             // fixme - and we cannot inject a DistributedCache yet
             // so doing all this mess
-            Container.RegisterSingleton<IServerMessenger, LocalServerMessenger>();
-            Container.RegisterSingleton(f => Mock.Of<IServerRegistrar>());
-            Container.RegisterCollectionBuilder<CacheRefresherCollectionBuilder>()
-                .Add(f => f.TryGetInstance<TypeLoader>().GetCacheRefreshers());
+            Composition.RegisterUnique<IServerMessenger, LocalServerMessenger>();
+            Composition.RegisterUnique(f => Mock.Of<IServerRegistrar>());
+            Composition.WithCollectionBuilder<CacheRefresherCollectionBuilder>()
+                .Add(() => Composition.TypeLoader.GetCacheRefreshers());
         }
 
         [TearDown]
@@ -65,7 +64,7 @@ namespace Umbraco.Tests.Scoping
         //  xmlStore.Xml - the actual main xml document
         //  publishedContentCache.GetXml() - the captured xml
 
-        private static XmlStore XmlStore => (Current.Container.GetInstance<IPublishedSnapshotService>() as PublishedSnapshotService).XmlStore;
+        private static XmlStore XmlStore => (Current.Factory.GetInstance<IPublishedSnapshotService>() as PublishedSnapshotService).XmlStore;
         private static XmlDocument XmlMaster => XmlStore.Xml;
         private static XmlDocument XmlInContext => ((PublishedContentCache) Umbraco.Web.Composing.Current.UmbracoContext.ContentCache).GetXml(false);
 

src/Umbraco.Tests/Services/ContentServicePerformanceTest.cs

@@ -5,6 +5,8 @@ using System.Linq;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
+using Umbraco.Core.Cache;
+using Umbraco.Core.Composing;
 using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
@@ -34,7 +36,7 @@ namespace Umbraco.Tests.Services
         protected override void Compose()
         {
             base.Compose();
-            Container.Register<IProfiler, TestProfiler>();
+            Composition.Register<IProfiler, TestProfiler>();
         }
 
         [Test]
@@ -43,7 +45,7 @@ namespace Umbraco.Tests.Services
             Assert.IsInstanceOf<TestProfiler>(Current.Profiler);
         }
 
-        private static ProfilingLogger GetTestProfilingLogger()
+        private static IProfilingLogger GetTestProfilingLogger()
         {
             var logger = new DebugDiagnosticsLogger();
             var profiler = new TestProfiler();
@@ -161,11 +163,11 @@ namespace Umbraco.Tests.Services
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var tRepository = new TemplateRepository((IScopeAccessor) provider, DisabledCache, Logger, Mock.Of<ITemplatesSection>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>());
-                var tagRepo = new TagRepository((IScopeAccessor) provider, DisabledCache, Logger);
-                var ctRepository = new ContentTypeRepository((IScopeAccessor) provider, DisabledCache, Logger, tRepository);
-                var languageRepository = new LanguageRepository((IScopeAccessor) provider, DisabledCache, Logger);
-                var repository = new DocumentRepository((IScopeAccessor) provider, DisabledCache, Logger, ctRepository, tRepository, tagRepo, languageRepository, Mock.Of<IContentSection>());
+                var tRepository = new TemplateRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger, Mock.Of<ITemplatesSection>(), TestObjects.GetFileSystemsMock());
+                var tagRepo = new TagRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger);
+                var ctRepository = new ContentTypeRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger, tRepository);
+                var languageRepository = new LanguageRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger);
+                var repository = new DocumentRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger, ctRepository, tRepository, tagRepo, languageRepository, Mock.Of<IContentSection>());
 
                 // Act
                 Stopwatch watch = Stopwatch.StartNew();
@@ -194,11 +196,11 @@ namespace Umbraco.Tests.Services
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var tRepository = new TemplateRepository((IScopeAccessor) provider, DisabledCache, Logger, Mock.Of<ITemplatesSection>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>());
-                var tagRepo = new TagRepository((IScopeAccessor) provider, DisabledCache, Logger);
-                var ctRepository = new ContentTypeRepository((IScopeAccessor) provider, DisabledCache, Logger, tRepository);
-                var languageRepository = new LanguageRepository((IScopeAccessor) provider, DisabledCache, Logger);
-                var repository = new DocumentRepository((IScopeAccessor) provider, DisabledCache, Logger, ctRepository, tRepository, tagRepo, languageRepository, Mock.Of<IContentSection>());
+                var tRepository = new TemplateRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger, Mock.Of<ITemplatesSection>(), TestObjects.GetFileSystemsMock());
+                var tagRepo = new TagRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger);
+                var ctRepository = new ContentTypeRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger, tRepository);
+                var languageRepository = new LanguageRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger);
+                var repository = new DocumentRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger, ctRepository, tRepository, tagRepo, languageRepository, Mock.Of<IContentSection>());
 
                 // Act
                 Stopwatch watch = Stopwatch.StartNew();
@@ -225,11 +227,11 @@ namespace Umbraco.Tests.Services
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var tRepository = new TemplateRepository((IScopeAccessor) provider, DisabledCache, Logger, Mock.Of<ITemplatesSection>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>());
-                var tagRepo = new TagRepository((IScopeAccessor) provider, DisabledCache, Logger);
-                var ctRepository = new ContentTypeRepository((IScopeAccessor) provider, DisabledCache, Logger, tRepository);
-                var languageRepository = new LanguageRepository((IScopeAccessor) provider, DisabledCache, Logger);
-                var repository = new DocumentRepository((IScopeAccessor) provider, DisabledCache, Logger, ctRepository, tRepository, tagRepo, languageRepository, Mock.Of<IContentSection>());
+                var tRepository = new TemplateRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger, Mock.Of<ITemplatesSection>(), TestObjects.GetFileSystemsMock());
+                var tagRepo = new TagRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger);
+                var ctRepository = new ContentTypeRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger, tRepository);
+                var languageRepository = new LanguageRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger);
+                var repository = new DocumentRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger, ctRepository, tRepository, tagRepo, languageRepository, Mock.Of<IContentSection>());
 
                 // Act
                 var contents = repository.GetMany();
@@ -259,11 +261,11 @@ namespace Umbraco.Tests.Services
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var tRepository = new TemplateRepository((IScopeAccessor) provider, DisabledCache, Logger, Mock.Of<ITemplatesSection>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>());
-                var tagRepo = new TagRepository((IScopeAccessor) provider, DisabledCache, Logger);
-                var ctRepository = new ContentTypeRepository((IScopeAccessor) provider, DisabledCache, Logger, tRepository);
-                var languageRepository = new LanguageRepository((IScopeAccessor) provider, DisabledCache, Logger);
-                var repository = new DocumentRepository((IScopeAccessor) provider, DisabledCache, Logger, ctRepository, tRepository, tagRepo, languageRepository, Mock.Of<IContentSection>());
+                var tRepository = new TemplateRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger, Mock.Of<ITemplatesSection>(), TestObjects.GetFileSystemsMock());
+                var tagRepo = new TagRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger);
+                var ctRepository = new ContentTypeRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger, tRepository);
+                var languageRepository = new LanguageRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger);
+                var repository = new DocumentRepository((IScopeAccessor) provider, CacheHelper.Disabled, Logger, ctRepository, tRepository, tagRepo, languageRepository, Mock.Of<IContentSection>());
 
                 // Act
                 var contents = repository.GetMany();

src/Umbraco.Tests/Services/ContentServiceTagsTests.cs

@@ -1,6 +1,6 @@
 using System;
 using System.Linq;
-using LightInject;
+using Umbraco.Core.Composing;
 using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Core.Models;
@@ -36,7 +36,7 @@ namespace Umbraco.Tests.Services
             base.Compose();
 
             // fixme - do it differently
-            Container.Register(factory => factory.GetInstance<ServiceContext>().TextService);
+            Composition.Register(factory => factory.GetInstance<ServiceContext>().TextService);
         }
 
         [Test]

src/Umbraco.Tests/Services/ContentServiceTests.cs

@@ -7,10 +7,8 @@ using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Core.Configuration.UmbracoSettings;
-using Umbraco.Core.IO;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Membership;
-using LightInject;
 using Umbraco.Core.Services;
 using Umbraco.Tests.TestHelpers.Entities;
 using Umbraco.Core.Events;
@@ -22,6 +20,8 @@ using Umbraco.Core.Services.Implement;
 using Umbraco.Tests.Testing;
 using System.Reflection;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
+using Umbraco.Core.Cache;
+using Umbraco.Core.Composing;
 
 namespace Umbraco.Tests.Services
 {
@@ -31,6 +31,7 @@ namespace Umbraco.Tests.Services
     /// as well as configuration.
     /// </summary>
     [TestFixture]
+    [Category("Slow")]
     [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest,
         PublishedRepositoryEvents = true,
         WithApplication = true,
@@ -56,8 +57,7 @@ namespace Umbraco.Tests.Services
         {
             base.Compose();
 
-            // fixme - do it differently
-            Container.Register(factory => factory.GetInstance<ServiceContext>().TextService);
+            Composition.RegisterUnique(factory => Mock.Of<ILocalizedTextService>());
         }
 
         /// <summary>
@@ -222,7 +222,7 @@ namespace Umbraco.Tests.Services
                     c.ContentSchedule.Add(now.AddSeconds(5), null); //release in 5 seconds
                     var r = ServiceContext.ContentService.Save(c);
                     Assert.IsTrue(r.Success, r.Result.ToString());
-                }   
+                }
                 else
                 {
                     c.ContentSchedule.Add(null, now.AddSeconds(5)); //expire in 5 seconds
@@ -258,7 +258,7 @@ namespace Umbraco.Tests.Services
                 variant.Add(c);
             }
 
-            
+
             var runSched = ServiceContext.ContentService.PerformScheduledPublish(
                 now.AddMinutes(1)).ToList(); //process anything scheduled before a minute from now
 
@@ -742,7 +742,7 @@ namespace Umbraco.Tests.Services
         public void Can_Unpublish_Content_Variation()
         {
             // Arrange
-            
+
             var langUk = new Language("en-GB") { IsDefault = true };
             var langFr = new Language("fr-FR");
 
@@ -1066,7 +1066,7 @@ namespace Umbraco.Tests.Services
                 foreach (var x in descendants)
                     Console.WriteLine("          ".Substring(0, x.Level) + x.Id);
             }
-            
+
             Console.WriteLine();
 
             // publish parent & its branch
@@ -1420,7 +1420,7 @@ namespace Umbraco.Tests.Services
             var descendants = new List<IContent>();
             while(page * pageSize < total)
                 descendants.AddRange(contentService.GetPagedDescendants(content.Id, page++, pageSize, out total));
-            
+
             Assert.AreNotEqual(-20, content.ParentId);
             Assert.IsFalse(content.Trashed);
             Assert.AreEqual(3, descendants.Count);
@@ -2989,11 +2989,11 @@ namespace Umbraco.Tests.Services
         private DocumentRepository CreateRepository(IScopeProvider provider, out ContentTypeRepository contentTypeRepository)
         {
             var accessor = (IScopeAccessor) provider;
-            var templateRepository = new TemplateRepository(accessor, DisabledCache, Logger, Mock.Of<ITemplatesSection>(), Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>());
-            var tagRepository = new TagRepository(accessor, DisabledCache, Logger);
-            contentTypeRepository = new ContentTypeRepository(accessor, DisabledCache, Logger, templateRepository);
-            var languageRepository = new LanguageRepository(accessor, DisabledCache, Logger);
-            var repository = new DocumentRepository(accessor, DisabledCache, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, Mock.Of<IContentSection>());
+            var templateRepository = new TemplateRepository(accessor, CacheHelper.Disabled, Logger, Mock.Of<ITemplatesSection>(), TestObjects.GetFileSystemsMock());
+            var tagRepository = new TagRepository(accessor, CacheHelper.Disabled, Logger);
+            contentTypeRepository = new ContentTypeRepository(accessor, CacheHelper.Disabled, Logger, templateRepository);
+            var languageRepository = new LanguageRepository(accessor, CacheHelper.Disabled, Logger);
+            var repository = new DocumentRepository(accessor, CacheHelper.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, Mock.Of<IContentSection>());
             return repository;
         }
     }

src/Umbraco.Tests/Services/ContentTypeServiceTests.cs

@@ -17,6 +17,7 @@ using Umbraco.Tests.Scoping;
 namespace Umbraco.Tests.Services
 {
     [TestFixture]
+    [Category("Slow")]
     [Apartment(ApartmentState.STA)]
     [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest, PublishedRepositoryEvents = true)]
     public class ContentTypeServiceTests : TestWithSomeContentBase

src/Umbraco.Tests/Services/ContentTypeServiceVariantsTests.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
-using LightInject;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
@@ -35,10 +34,10 @@ namespace Umbraco.Tests.Services
             base.Compose();
 
             // pfew - see note in ScopedNuCacheTests?
-            Container.RegisterSingleton<IServerMessenger, LocalServerMessenger>();
-            Container.RegisterSingleton(f => Mock.Of<IServerRegistrar>());
-            Container.RegisterCollectionBuilder<CacheRefresherCollectionBuilder>()
-                .Add(f => f.TryGetInstance<TypeLoader>().GetCacheRefreshers());
+            Composition.RegisterUnique<IServerMessenger, LocalServerMessenger>();
+            Composition.RegisterUnique(f => Mock.Of<IServerRegistrar>());
+            Composition.WithCollectionBuilder<CacheRefresherCollectionBuilder>()
+                .Add(() => Composition.TypeLoader.GetCacheRefreshers());
         }
 
         protected override IPublishedSnapshotService CreatePublishedSnapshotService()
@@ -50,7 +49,7 @@ namespace Umbraco.Tests.Services
 
             var contentTypeFactory = new PublishedContentTypeFactory(Mock.Of<IPublishedModelFactory>(), new PropertyValueConverterCollection(Array.Empty<IPropertyValueConverter>()), Mock.Of<IDataTypeService>());
             //var documentRepository = Mock.Of<IDocumentRepository>();
-            var documentRepository = Container.GetInstance<IDocumentRepository>();
+            var documentRepository = Factory.GetInstance<IDocumentRepository>();
             var mediaRepository = Mock.Of<IMediaRepository>();
             var memberRepository = Mock.Of<IMemberRepository>();
 
@@ -68,7 +67,7 @@ namespace Umbraco.Tests.Services
                 documentRepository, mediaRepository, memberRepository,
                 DefaultCultureAccessor,
                 new DatabaseDataSource(),
-                Container.GetInstance<IGlobalSettings>(), new SiteDomainHelper());
+                Factory.GetInstance<IGlobalSettings>(), new SiteDomainHelper());
         }
 
         public class LocalServerMessenger : ServerMessengerBase
@@ -770,4 +769,4 @@ namespace Umbraco.Tests.Services
                 "{'properties':{'value11':[{'culture':'','seg':'','val':'v11'}],'value12':[{'culture':'','seg':'','val':'v12'}],'value31':[{'culture':'','seg':'','val':'v31'}],'value32':[{'culture':'','seg':'','val':'v32'}]},'cultureData':");
         }
     }
-}
+}

src/Umbraco.Tests/Services/Importing/PackageImportTests.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Xml.Linq;
@@ -7,15 +6,16 @@ using NUnit.Framework;
 using Umbraco.Core.Models;
 using Umbraco.Core;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Composing.Composers;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence.Dtos;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Tests.Testing;
-using LightInject;
 
 namespace Umbraco.Tests.Services.Importing
 {
     [TestFixture]
+    [Category("Slow")]
     [Apartment(ApartmentState.STA)]
     [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
     public class PackageImportTests : TestWithSomeContentBase
@@ -49,11 +49,21 @@ namespace Umbraco.Tests.Services.Importing
             // pollute everything, they are ignored by the type finder and explicitely
             // added to the editors collection
 
-            Container.GetInstance<DataEditorCollectionBuilder>()
+            Composition.WithCollectionBuilder<DataEditorCollectionBuilder>()
                 .Add<Editor1>()
                 .Add<Editor2>();
         }
 
+        protected override void ComposeApplication(bool withApplication)
+        {
+            base.ComposeApplication(withApplication);
+
+            if (!withApplication) return;
+
+            // re-register with actual media fs
+            Composition.ComposeFileSystems();
+        }
+
         [Test]
         public void PackagingService_Can_Import_uBlogsy_ContentTypes_And_Verify_Structure()
         {

src/Umbraco.Tests/Services/MacroServiceTests.cs

@@ -26,7 +26,7 @@ namespace Umbraco.Tests.Services
             var provider = TestObjects.GetScopeProvider(Logger);
             using (var scope = provider.CreateScope())
             {
-                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>());
+                var repository = new MacroRepository((IScopeAccessor) provider, CacheHelper.Disabled, Mock.Of<ILogger>());
 
                 repository.Save(new Macro("test1", "Test1", "~/views/macropartials/test1.cshtml", MacroTypes.PartialView));
                 repository.Save(new Macro("test2", "Test2", "~/views/macropartials/test2.cshtml", MacroTypes.PartialView));

src/Umbraco.Tests/Services/MemberServiceTests.cs

@@ -24,6 +24,7 @@ using Umbraco.Web.Security.Providers;
 namespace Umbraco.Tests.Services
 {
     [TestFixture]
+    [Category("Slow")]
     [Apartment(ApartmentState.STA)]
     [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest, PublishedRepositoryEvents = true, WithApplication = true)]
     public class MemberServiceTests : TestWithSomeContentBase

src/Umbraco.Tests/Services/PerformanceTests.cs

@@ -57,7 +57,7 @@ namespace Umbraco.Tests.Services
               base.TearDown();
         }
 
-        private static ProfilingLogger GetTestProfilingLogger()
+        private static IProfilingLogger GetTestProfilingLogger()
         {
             var logger = new DebugDiagnosticsLogger();
             var profiler = new TestProfiler();

src/Umbraco.Tests/Strings/DefaultShortStringHelperTests.cs

@@ -1,15 +1,13 @@
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Globalization;
 using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
-using LightInject;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
-using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.Strings;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Tests.Testing;
@@ -71,7 +69,7 @@ namespace Umbraco.Tests.Strings
                 }));
 
             // fixme - move to a "compose" thing?
-            Container.RegisterSingleton<IShortStringHelper>(f => _helper);
+            Composition.RegisterUnique<IShortStringHelper>(f => _helper);
         }
 
         private static readonly Regex FrenchElisionsRegex = new Regex("\\b(c|d|j|l|m|n|qu|s|t)('|\u8217)", RegexOptions.Compiled | RegexOptions.IgnoreCase);

src/Umbraco.Tests/Strings/StringExtensionsTests.cs

@@ -1,15 +1,11 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Globalization;
 using System.Linq;
-using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Core.Composing;
-using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.Strings;
-using Umbraco.Tests.TestHelpers;
 using Umbraco.Tests.Testing;
 
 namespace Umbraco.Tests.Strings
@@ -17,12 +13,10 @@ namespace Umbraco.Tests.Strings
     [TestFixture]
     public class StringExtensionsTests : UmbracoTestBase
     {
-        public override void SetUp()
+        protected override void Compose()
         {
-            base.SetUp();
-
-            // fixme - in "compose"?
-            Container.RegisterSingleton<IShortStringHelper>(_ => new MockShortStringHelper());
+            base.Compose();
+            Composition.RegisterUnique<IShortStringHelper>(_ => new MockShortStringHelper());
         }
 
         [Test]
@@ -75,6 +69,17 @@ namespace Umbraco.Tests.Strings
             Assert.AreEqual(stripped, result);
         }
 
+        [TestCase("'+alert(1234)+'", "+alert1234+")]
+        [TestCase("'+alert(56+78)+'", "+alert56+78+")]
+        [TestCase("{{file}}", "file")]
+        [TestCase("'+alert('hello')+'", "+alerthello+")]
+        [TestCase("Test", "Test")]
+        public void Clean_From_XSS(string input, string result)
+        {
+            var cleaned = input.CleanForXss();
+            Assert.AreEqual(cleaned, result);
+        }
+
         [TestCase("This is a string to encrypt")]
         [TestCase("This is a string to encrypt\nThis is a second line")]
         [TestCase("    White space is preserved    ")]

src/Umbraco.Tests/Templates/TemplateRepositoryTests.cs

@@ -6,9 +6,6 @@ using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
-using Umbraco.Core.Persistence;
-using Umbraco.Core.Persistence.Querying;
-using Umbraco.Core.Persistence.Repositories;
 using Umbraco.Core.Persistence.Repositories.Implement;
 using Umbraco.Core.Scoping;
 using Umbraco.Tests.TestHelpers;
@@ -19,12 +16,11 @@ namespace Umbraco.Tests.Templates
     public class TemplateRepositoryTests
     {
         private readonly Mock<CacheHelper> _cacheMock = new Mock<CacheHelper>();
-        private readonly Mock<IFileSystem> _viewFileSystemMock = new Mock<IFileSystem>();
-        private readonly Mock<IFileSystem> _masterpageFileSystemMock = new Mock<IFileSystem>();
         private readonly Mock<ITemplatesSection> _templateConfigMock = new Mock<ITemplatesSection>();
+        private readonly IFileSystems _fileSystems = Mock.Of<IFileSystems>();
         private TemplateRepository _templateRepository;
 
-        private readonly TestObjects TestObjects = new TestObjects(null);
+        private readonly TestObjects _testObjects = new TestObjects(null);
 
         [SetUp]
         public void Setup()
@@ -33,12 +29,16 @@ namespace Umbraco.Tests.Templates
 
             var accessorMock = new Mock<IScopeAccessor>();
             var scopeMock = new Mock<IScope>();
-            var database = TestObjects.GetUmbracoSqlCeDatabase(logger);
+            var database = _testObjects.GetUmbracoSqlCeDatabase(logger);
             scopeMock.Setup(x => x.Database).Returns(database);
             accessorMock.Setup(x => x.AmbientScope).Returns(scopeMock.Object);
 
-            _templateRepository = new TemplateRepository(accessorMock.Object, _cacheMock.Object, logger, _templateConfigMock.Object, _masterpageFileSystemMock.Object, _viewFileSystemMock.Object);
+            var mvcFs = Mock.Of<IFileSystem>();
+            var masterFs = Mock.Of<IFileSystem>();
+            Mock.Get(_fileSystems).Setup(x => x.MvcViewsFileSystem).Returns(mvcFs);
+            Mock.Get(_fileSystems).Setup(x => x.MasterPagesFileSystem).Returns(masterFs);
 
+            _templateRepository = new TemplateRepository(accessorMock.Object, _cacheMock.Object, logger, _templateConfigMock.Object, _fileSystems);
         }
 
         [Test]
@@ -53,7 +53,8 @@ namespace Umbraco.Tests.Templates
             templateMock.Setup(x => x.Content).Returns("<asp:Content />");
 
             // but MVC View already exists
-            _viewFileSystemMock.Setup(x => x.FileExists(It.IsAny<string>())).Returns(true);
+            Mock.Get(_fileSystems.MvcViewsFileSystem)
+                .Setup(x => x.FileExists(It.IsAny<string>())).Returns(true);
 
             var res = _templateRepository.DetermineTemplateRenderingEngine(templateMock.Object);
             Assert.AreEqual(RenderingEngine.Mvc, res);
@@ -71,7 +72,8 @@ namespace Umbraco.Tests.Templates
             templateMock.Setup(x => x.Content).Returns("<asp:Content />");
 
             // MVC View doesn't exist
-            _viewFileSystemMock.Setup(x => x.FileExists(It.IsAny<string>())).Returns(false);
+            Mock.Get(_fileSystems.MvcViewsFileSystem)
+                .Setup(x => x.FileExists(It.IsAny<string>())).Returns(false);
 
             var res = _templateRepository.DetermineTemplateRenderingEngine(templateMock.Object);
             Assert.AreEqual(RenderingEngine.WebForms, res);
@@ -87,8 +89,10 @@ namespace Umbraco.Tests.Templates
             templateMock.Setup(x => x.Alias).Returns("Something");
 
             // but masterpage already exists
-            _viewFileSystemMock.Setup(x => x.FileExists(It.IsAny<string>())).Returns(false);
-            _masterpageFileSystemMock.Setup(x => x.FileExists(It.IsAny<string>())).Returns(true);
+            Mock.Get(_fileSystems.MvcViewsFileSystem)
+                .Setup(x => x.FileExists(It.IsAny<string>())).Returns(false);
+            Mock.Get(_fileSystems.MasterPagesFileSystem)
+                .Setup(x => x.FileExists(It.IsAny<string>())).Returns(true);
 
             var res = _templateRepository.DetermineTemplateRenderingEngine(templateMock.Object);
             Assert.AreEqual(RenderingEngine.WebForms, res);
@@ -104,8 +108,10 @@ namespace Umbraco.Tests.Templates
             templateMock.Setup(x => x.Alias).Returns("Something");
 
             // but MVC View already exists
-            _viewFileSystemMock.Setup(x => x.FileExists(It.IsAny<string>())).Returns(true);
-            _masterpageFileSystemMock.Setup(x => x.FileExists(It.IsAny<string>())).Returns(false);
+            Mock.Get(_fileSystems.MvcViewsFileSystem)
+                .Setup(x => x.FileExists(It.IsAny<string>())).Returns(true);
+            Mock.Get(_fileSystems.MasterPagesFileSystem)
+                .Setup(x => x.FileExists(It.IsAny<string>())).Returns(false);
 
             var res = _templateRepository.DetermineTemplateRenderingEngine(templateMock.Object);
             Assert.AreEqual(RenderingEngine.Mvc, res);