From 8f92ac2ea66df72f868a3b177080e698ee305560 Mon Sep 17 00:00:00 2001
From: alexmg <alex.meyergleaves@gmail.com>
Date: Wed, 20 Mar 2019 23:57:28 +1000
Subject: [PATCH] Additional unit tests related to #965 to make sure decorators
 can be applied more than once if intentional.

---
 .../Features/DecoratorTests.cs                | 37 +++++++++++++++++++
 .../Decorators/OpenGenericDecoratorTests.cs   | 36 ++++++++++++++++++
 2 files changed, 73 insertions(+)

diff --git a/test/Autofac.Specification.Test/Features/DecoratorTests.cs b/test/Autofac.Specification.Test/Features/DecoratorTests.cs
index ed16e69a6..e3174d235 100644
--- a/test/Autofac.Specification.Test/Features/DecoratorTests.cs
+++ b/test/Autofac.Specification.Test/Features/DecoratorTests.cs
@@ -276,10 +276,47 @@ public void DecoratorAppliedOnlyOnceToComponentWithExternalRegistrySource()
 
             var scope = container.BeginLifetimeScope(b => { });
             var service = scope.Resolve<IDecoratedService>();
+
             Assert.IsType<DecoratorA>(service);
             Assert.IsType<ImplementorA>(service.Decorated);
         }
 
+        [Fact]
+        public void DecoratorCanBeAppliedTwice()
+        {
+            var builder = new ContainerBuilder();
+            builder.RegisterType<ImplementorA>().As<IDecoratedService>();
+            builder.RegisterDecorator<DecoratorA, IDecoratedService>();
+            builder.RegisterDecorator<DecoratorA, IDecoratedService>();
+            var container = builder.Build();
+
+            var service = container.Resolve<IDecoratedService>();
+
+            Assert.IsType<DecoratorA>(service);
+            Assert.IsType<DecoratorA>(service.Decorated);
+            Assert.IsType<ImplementorA>(service.Decorated.Decorated);
+        }
+
+        [Fact]
+        public void DecoratorCanBeAppliedTwiceInChildLifetimeScope()
+        {
+            var builder = new ContainerBuilder();
+            builder.RegisterType<ImplementorA>().As<IDecoratedService>();
+            builder.RegisterDecorator<DecoratorA, IDecoratedService>();
+            var container = builder.Build();
+
+            var scope = container.BeginLifetimeScope(b => b.RegisterDecorator<DecoratorA, IDecoratedService>());
+            var scopeInstance = scope.Resolve<IDecoratedService>();
+
+            Assert.IsType<DecoratorA>(scopeInstance);
+            Assert.IsType<DecoratorA>(scopeInstance.Decorated);
+            Assert.IsType<ImplementorA>(scopeInstance.Decorated.Decorated);
+
+            var rootInstance = container.Resolve<IDecoratedService>();
+            Assert.IsType<DecoratorA>(rootInstance);
+            Assert.IsType<ImplementorA>(rootInstance.Decorated);
+        }
+
         [Fact]
         public void DecoratorCanBeAppliedToServiceRegisteredInChildLifetimeScope()
         {
diff --git a/test/Autofac.Test/Features/Decorators/OpenGenericDecoratorTests.cs b/test/Autofac.Test/Features/Decorators/OpenGenericDecoratorTests.cs
index d3c8aa874..35dbe802f 100644
--- a/test/Autofac.Test/Features/Decorators/OpenGenericDecoratorTests.cs
+++ b/test/Autofac.Test/Features/Decorators/OpenGenericDecoratorTests.cs
@@ -550,6 +550,42 @@ public void DecoratorAppliedOnlyOnceToComponentWithExternalRegistrySource()
             Assert.IsType<ImplementorA<int>>(service.Decorated);
         }
 
+        [Fact]
+        public void DecoratorCanBeAppliedTwice()
+        {
+            var builder = new ContainerBuilder();
+            builder.RegisterGeneric(typeof(ImplementorA<>)).As(typeof(IDecoratedService<>));
+            builder.RegisterGenericDecorator(typeof(DecoratorA<>), typeof(IDecoratedService<>));
+            builder.RegisterGenericDecorator(typeof(DecoratorA<>), typeof(IDecoratedService<>));
+            var container = builder.Build();
+
+            var service = container.Resolve<IDecoratedService<int>>();
+
+            Assert.IsType<DecoratorA<int>>(service);
+            Assert.IsType<DecoratorA<int>>(service.Decorated);
+            Assert.IsType<ImplementorA<int>>(service.Decorated.Decorated);
+        }
+
+        [Fact]
+        public void DecoratorCanBeAppliedTwiceInChildLifetimeScope()
+        {
+            var builder = new ContainerBuilder();
+            builder.RegisterGeneric(typeof(ImplementorA<>)).As(typeof(IDecoratedService<>));
+            builder.RegisterGenericDecorator(typeof(DecoratorA<>), typeof(IDecoratedService<>));
+            var container = builder.Build();
+
+            var scope = container.BeginLifetimeScope(b => b.RegisterGenericDecorator(typeof(DecoratorA<>), typeof(IDecoratedService<>)));
+            var scopeInstance = scope.Resolve<IDecoratedService<int>>();
+
+            Assert.IsType<DecoratorA<int>>(scopeInstance);
+            Assert.IsType<DecoratorA<int>>(scopeInstance.Decorated);
+            Assert.IsType<ImplementorA<int>>(scopeInstance.Decorated.Decorated);
+
+            var rootInstance = container.Resolve<IDecoratedService<int>>();
+            Assert.IsType<DecoratorA<int>>(rootInstance);
+            Assert.IsType<ImplementorA<int>>(rootInstance.Decorated);
+        }
+
         [Fact]
         public void DecoratorCanBeAppliedToServiceRegisteredInChildLifetimeScope()
         {