Address review feedback on #1459 tests

- Convert the closed-generic DerivedDependencyDecorator from a record to a
  plain class for consistency with the other decorator types in the file.
- Add a decorator-chain regression test exercising the DecoratorContext
  UpdateContext path: the outer decorator's more-derived dependency must
  still resolve from the container when the chained instance (inner
  decorator output) is not assignable to it. Fails with InvalidCastException
  against the pre-fix middleware.
- Add a test asserting a clean DependencyResolutionException when the
  more-derived dependency is unregistered (rather than InvalidCastException).
- Make the open-generic test self-contained with a purpose-built
  IDerivedService<T> sub-interface instead of reusing shared test infra.

Author: tillig

test/Autofac.Test/Features/Decorators/DecoratorTests.cs

@@ -244,7 +244,37 @@ private class DerivedImpl : IDerived
     {
     }
 
-    private record DerivedDependencyDecorator(IDerived Derived, IBase Decorated) : IBase;
+    private class DerivedDependencyDecorator : IBase
+    {
+        public DerivedDependencyDecorator(IDerived derived, IBase decorated)
+        {
+            Derived = derived;
+            Decorated = decorated;
+        }
+
+        public IDerived Derived
+        {
+            get;
+        }
+
+        public IBase Decorated
+        {
+            get;
+        }
+    }
+
+    private class BaseDecorator : IBase
+    {
+        public BaseDecorator(IBase decorated)
+        {
+            Decorated = decorated;
+        }
+
+        public IBase Decorated
+        {
+            get;
+        }
+    }
 
     [Fact]
     public void DecoratorWithMoreDerivedServiceDependencyResolvesDependencyNormally()
@@ -267,6 +297,53 @@ public void DecoratorWithMoreDerivedServiceDependencyResolvesDependencyNormally(
         Assert.IsType<DerivedImpl>(decorator.Derived);
     }
 
+    [Fact]
+    public void DecoratorWithMoreDerivedServiceDependencyResolvesDependencyNormallyInChain()
+    {
+        // Issue 1459: When decorators are chained, the decorated instance seen by
+        // the outer decorator is the inner decorator's output (via
+        // DecoratorContext.UpdateContext), which is an IBase but not an IDerived.
+        // The outer decorator's more-derived "Derived" (IDerived) parameter must
+        // still be resolved from the container rather than receiving that chained
+        // instance, while "Decorated" receives the inner decorator.
+        var builder = new ContainerBuilder();
+        builder.RegisterType<BaseImpl>().As<IBase>();
+        builder.RegisterType<DerivedImpl>().As<IDerived>();
+
+        // Registered first => innermost decorator.
+        builder.RegisterDecorator<BaseDecorator, IBase>();
+        builder.RegisterDecorator<DerivedDependencyDecorator, IBase>();
+
+        var container = builder.Build();
+
+        var resolved = container.Resolve<IBase>();
+
+        var outer = Assert.IsType<DerivedDependencyDecorator>(resolved);
+        Assert.IsType<DerivedImpl>(outer.Derived);
+
+        var inner = Assert.IsType<BaseDecorator>(outer.Decorated);
+        Assert.IsType<BaseImpl>(inner.Decorated);
+    }
+
+    [Fact]
+    public void DecoratorWithUnregisteredMoreDerivedServiceDependencyThrowsResolutionException()
+    {
+        // Issue 1459: When the more-derived "Derived" (IDerived) parameter is not
+        // registered, the parameter falls through to normal autowiring, which
+        // cannot satisfy it. The result should be a clean DependencyResolutionException
+        // rather than the previous InvalidCastException from force-injecting the
+        // decorated instance.
+        var builder = new ContainerBuilder();
+        builder.RegisterType<BaseImpl>().As<IBase>();
+
+        // IDerived is intentionally not registered.
+        builder.RegisterDecorator<DerivedDependencyDecorator, IBase>();
+
+        var container = builder.Build();
+
+        Assert.Throws<DependencyResolutionException>(() => container.Resolve<IBase>());
+    }
+
     private abstract class Decorator : IDecoratedService
     {
         protected Decorator(IDecoratedService decorated)

test/Autofac.Test/Features/Decorators/OpenGenericDecoratorTests.cs

@@ -926,19 +926,28 @@ public void ResolvesMultipleDecoratedServicesWhenResolvedByOtherServices()
     // Issue 1459: A decorator constructor may take a dependency typed as a more
     // derived service than the one being decorated. The decorated instance must
     // not be force-injected into that parameter; it should be resolved normally.
+    // ReSharper disable once UnusedTypeParameter
+    private interface IDerivedService<T> : IService<T>
+    {
+    }
+
     private class PlainService<T> : IService<T>
     {
     }
 
+    private class DerivedServiceImpl<T> : IDerivedService<T>
+    {
+    }
+
     private class DerivedDependencyDecorator<T> : IService<T>
     {
-        public DerivedDependencyDecorator(IDecoratedService<T> derived, IService<T> decorated)
+        public DerivedDependencyDecorator(IDerivedService<T> derived, IService<T> decorated)
         {
             Derived = derived;
             Decorated = decorated;
         }
 
-        public IDecoratedService<T> Derived
+        public IDerivedService<T> Derived
         {
             get;
         }
@@ -954,20 +963,20 @@ public void DecoratorWithMoreDerivedServiceDependencyResolvesDependencyNormally(
     {
         // Issue 1459: The decorated service (IService<T>) should be supplied to
         // the "Decorated" parameter, while the more-derived "Derived"
-        // (IDecoratedService<T>) parameter must be resolved from the container
+        // (IDerivedService<T>) parameter must be resolved from the container
         // rather than receiving the decorated instance (which is only an
-        // IService<T> here, not an IDecoratedService<T>).
+        // IService<T> here, not an IDerivedService<T>).
         var builder = new ContainerBuilder();
         builder.RegisterGeneric(typeof(PlainService<>)).As(typeof(IService<>));
-        builder.RegisterGeneric(typeof(ImplementorA<>)).As(typeof(IDecoratedService<>));
+        builder.RegisterGeneric(typeof(DerivedServiceImpl<>)).As(typeof(IDerivedService<>));
         builder.RegisterGenericDecorator(typeof(DerivedDependencyDecorator<>), typeof(IService<>));
         var container = builder.Build();
 
         var resolved = container.Resolve<IService<int>>();
 
         var decorator = Assert.IsType<DerivedDependencyDecorator<int>>(resolved);
         Assert.IsType<PlainService<int>>(decorator.Decorated);
-        Assert.IsType<ImplementorA<int>>(decorator.Derived);
+        Assert.IsType<DerivedServiceImpl<int>>(decorator.Derived);
     }
 
     private interface ICommandHandler<T>