Split lifetime scope tests up.

test/Autofac.Specification.Test/Features/CircularDependencyTests.cs

@@ -19,5 +19,31 @@ public void DetectsCircularDependencies()
 
             var de = Assert.Throws<DependencyResolutionException>(() => container.Resolve<ID>());
         }
+
+        [Fact]
+        public void InstancePerLifetimeScopeServiceCannotCreateSecondInstanceOfSelfDuringConstruction()
+        {
+            var builder = new ContainerBuilder();
+            builder.RegisterType<AThatDependsOnB>().InstancePerLifetimeScope();
+            builder.RegisterType<BThatCreatesA>().InstancePerLifetimeScope();
+            var container = builder.Build();
+
+            var exception = Assert.Throws<DependencyResolutionException>(() => container.Resolve<AThatDependsOnB>());
+        }
+
+        private class AThatDependsOnB
+        {
+            public AThatDependsOnB(BThatCreatesA bThatCreatesA)
+            {
+            }
+        }
+
+        private class BThatCreatesA
+        {
+            public BThatCreatesA(Func<BThatCreatesA, AThatDependsOnB> factory)
+            {
+                factory(this);
+            }
+        }
     }
 }

test/Autofac.Specification.Test/Lifetime/DisposalOrderTests.cs → test/Autofac.Specification.Test/Lifetime/DisposalTests.cs

@@ -5,8 +5,30 @@
 
 namespace Autofac.Specification.Test.Lifetime
 {
-    public class DisposalOrderTests
+    public class DisposalTests
     {
+        [Fact]
+        public void ComponentsAreDisposedEvenIfCurrentScopeEndingThrowsException()
+        {
+            var rootScope = new ContainerBuilder().Build();
+
+            var nestedScope = rootScope.BeginLifetimeScope(cb => cb.RegisterType<DisposeTracker>().SingleInstance());
+
+            nestedScope.CurrentScopeEnding += (sender, args) => throw new DivideByZeroException();
+
+            var dt = nestedScope.Resolve<DisposeTracker>();
+
+            try
+            {
+                nestedScope.Dispose();
+            }
+            catch (DivideByZeroException)
+            {
+            }
+
+            Assert.True(dt.IsDisposed);
+        }
+
         [Fact]
         public void ComponentsResolvedFromContainer_DisposedInReverseDependencyOrder()
         {
@@ -54,6 +76,29 @@ public void ComponentsResolvedFromContainerInReverseOrder_DisposedInReverseDepen
             Assert.Same(a, disposeOrder.Dequeue());
         }
 
+        [Fact]
+        public void InstancesRegisteredInParentScope_ButResolvedInChild_AreDisposedWithChild()
+        {
+            var builder = new ContainerBuilder();
+            builder.RegisterType<DisposeTracker>();
+            var parent = builder.Build();
+            var child = parent.BeginLifetimeScope(b => { });
+            var dt = child.Resolve<DisposeTracker>();
+            child.Dispose();
+            Assert.True(dt.IsDisposed);
+        }
+
+        [Fact]
+        public void ResolvingFromAnEndedLifetimeProducesObjectDisposedException()
+        {
+            var builder = new ContainerBuilder();
+            builder.RegisterType<object>();
+            var container = builder.Build();
+            var lifetime = container.BeginLifetimeScope();
+            lifetime.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => lifetime.Resolve<object>());
+        }
+
         private class A : DisposeTracker
         {
         }

test/Autofac.Specification.Test/Lifetime/NestedScopeTests.cs

@@ -0,0 +1,25 @@
+using System;
+using Xunit;
+
+namespace Autofac.Specification.Test.Lifetime
+{
+    /// <summary>
+    /// Tests involving the lifetime of a nested scope. Tests for registering objects in a nested scope are
+    /// in <see cref="Autofac.Specification.Test.Registration.NestedScopeRegistrationTests"/>. Tests for specifics
+    /// around disposal are in <see cref="Autofac.Specification.Test.Lifetime.DisposalTests"/> or in the fixture
+    /// for the specific lifetime model being tested (singleton, provided instance, etc.).
+    /// </summary>
+    public class NestedScopeTests
+    {
+        [Fact]
+        public void BeginLifetimeScopeCannotBeCalledWithDuplicateTag()
+        {
+            var rootScope = new ContainerBuilder().Build();
+            const string duplicateTagName = "ABC";
+            var taggedScope = rootScope.BeginLifetimeScope(duplicateTagName);
+            var differentTaggedScope = taggedScope.BeginLifetimeScope("DEF");
+
+            var exception = Assert.Throws<InvalidOperationException>(() => differentTaggedScope.BeginLifetimeScope(duplicateTagName));
+        }
+    }
+}

test/Autofac.Specification.Test/Lifetime/SingleInstanceTests.cs

@@ -10,6 +10,42 @@ private interface IA
         {
         }
 
+        [Fact]
+        public void SingletonsCanBeRegisteredInNestedScope()
+        {
+            var rootScope = new ContainerBuilder().Build();
+            var nestedScope = rootScope.BeginLifetimeScope(cb => cb.RegisterType<DisposeTracker>().SingleInstance());
+
+            var dt = nestedScope.Resolve<DisposeTracker>();
+            var dt1 = nestedScope.Resolve<DisposeTracker>();
+            Assert.Same(dt, dt1);
+        }
+
+        [Fact]
+        public void SingletonsRegisteredInContainerAreDisposedWithContainer()
+        {
+            var cb = new ContainerBuilder();
+            cb.RegisterType<DisposeTracker>().SingleInstance();
+            var c = cb.Build();
+            var a1 = c.Resolve<DisposeTracker>();
+            var lifetime = c.BeginLifetimeScope();
+            var a2 = lifetime.Resolve<DisposeTracker>();
+            lifetime.Dispose();
+            Assert.False(a1.IsDisposed);
+            c.Dispose();
+            Assert.True(a1.IsDisposed);
+        }
+
+        [Fact]
+        public void SingletonsRegisteredInNestedScopeAreDisposedWithThatScope()
+        {
+            var rootScope = new ContainerBuilder().Build();
+            var nestedScope = rootScope.BeginLifetimeScope(cb => cb.RegisterType<DisposeTracker>().SingleInstance());
+            var dt = nestedScope.Resolve<DisposeTracker>();
+            nestedScope.Dispose();
+            Assert.True(dt.IsDisposed);
+        }
+
         [Fact]
         public void TypeAsSingleInstance()
         {
@@ -29,23 +65,6 @@ public void TypeAsSingleInstance()
             Assert.Same(a1, a4);
         }
 
-        [Fact]
-        public void TypeAsSingleInstanceDisposedWithContainer()
-        {
-            var cb = new ContainerBuilder();
-            cb.RegisterType<A>()
-                .As<IA>()
-                .SingleInstance();
-            var c = cb.Build();
-            var a1 = c.Resolve<IA>();
-            var lifetime = c.BeginLifetimeScope();
-            var a2 = lifetime.Resolve<IA>();
-            lifetime.Dispose();
-            Assert.False(((A)a1).IsDisposed);
-            c.Dispose();
-            Assert.True(((A)a1).IsDisposed);
-        }
-
         private class A : DisposeTracker, IA
         {
         }