Increased test coverage.

Author: tillig

.vscode/settings.json

@@ -1,6 +1,7 @@
 {
   "cSpell.words": [
     "autofac",
+    "diagnoser",
     "netstandard",
     "xunit"
   ],

src/Autofac.Extras.AggregateService/GeneratedAggregateServiceRegistry.cs

@@ -32,14 +32,14 @@ namespace Autofac.Extras.AggregateService;
 /// </remarks>
 public static class GeneratedAggregateServiceRegistry
 {
-    private static readonly object SyncRoot = new object();
+    private static readonly object _syncRoot = new object();
 
     // Closed (non-generic, or already-closed generic) interface type -> factory.
-    private static readonly Dictionary<Type, Func<IComponentContext, object>> ClosedFactories =
+    private static readonly Dictionary<Type, Func<IComponentContext, object>> _closedFactories =
         new Dictionary<Type, Func<IComponentContext, object>>();
 
     // Open generic interface definition -> open generic backing class definition.
-    private static readonly Dictionary<Type, Type> OpenGenericBackings = new Dictionary<Type, Type>();
+    private static readonly Dictionary<Type, Type> _openGenericBackings = new Dictionary<Type, Type>();
 
     /// <summary>
     /// Registers a generated factory for a closed aggregate service interface
@@ -68,9 +68,9 @@ public static void Register(Type interfaceType, Func<IComponentContext, object>
             throw new ArgumentNullException(nameof(factory));
         }
 
-        lock (SyncRoot)
+        lock (_syncRoot)
         {
-            ClosedFactories[interfaceType] = factory;
+            _closedFactories[interfaceType] = factory;
         }
     }
 
@@ -101,9 +101,9 @@ public static void RegisterOpenGeneric(Type openInterfaceType, Type openBackingT
             throw new ArgumentNullException(nameof(openBackingType));
         }
 
-        lock (SyncRoot)
+        lock (_syncRoot)
         {
-            OpenGenericBackings[openInterfaceType] = openBackingType;
+            _openGenericBackings[openInterfaceType] = openBackingType;
         }
     }
 
@@ -133,11 +133,11 @@ internal static bool TryCreate(Type interfaceType, IComponentContext context, [N
         Func<IComponentContext, object>? factory = null;
         Type? openBacking = null;
 
-        lock (SyncRoot)
+        lock (_syncRoot)
         {
-            if (!ClosedFactories.TryGetValue(interfaceType, out factory) && interfaceType.IsConstructedGenericType)
+            if (!_closedFactories.TryGetValue(interfaceType, out factory) && interfaceType.IsConstructedGenericType)
             {
-                OpenGenericBackings.TryGetValue(interfaceType.GetGenericTypeDefinition(), out openBacking);
+                _openGenericBackings.TryGetValue(interfaceType.GetGenericTypeDefinition(), out openBacking);
             }
         }
 

src/Autofac.Extras.AggregateService/Polyfills.cs

@@ -19,6 +19,7 @@
 namespace System.Diagnostics.CodeAnalysis;
 
 #if !NETSTANDARD2_1_OR_GREATER
+[ExcludeFromCodeCoverage]
 [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
 internal sealed class NotNullWhenAttribute : Attribute
 {
@@ -34,6 +35,7 @@ public bool ReturnValue
 }
 #endif
 
+[ExcludeFromCodeCoverage]
 [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
 internal sealed class RequiresUnreferencedCodeAttribute : Attribute
 {
@@ -53,6 +55,7 @@ public string? Url
     }
 }
 
+[ExcludeFromCodeCoverage]
 [AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
 internal sealed class UnconditionalSuppressMessageAttribute : Attribute
 {
@@ -93,6 +96,7 @@ public string? Justification
     }
 }
 
+[ExcludeFromCodeCoverage]
 [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
 internal sealed class RequiresDynamicCodeAttribute : Attribute
 {

src/Autofac.Extras.AggregateService/ResolvingInterceptor.cs

@@ -61,7 +61,7 @@ public void Intercept(IInvocation invocation)
         }
 
         return method
-            .DeclaringType?
+            .DeclaringType!
             .GetProperties()
             .FirstOrDefault(prop => prop.GetGetMethod() == method);
     }
@@ -155,8 +155,7 @@ private Dictionary<MethodInfo, Action<IInvocation>> SetupInvocationMap(Type inte
             }
 
             // Methods without parameters
-            var methodWithoutParams = GetType().GetMethod(nameof(MethodWithoutParams), BindingFlags.Instance | BindingFlags.NonPublic)
-                ?? throw new InvalidOperationException($"Unable to locate the {nameof(MethodWithoutParams)} method via reflection.");
+            var methodWithoutParams = GetType().GetMethod(nameof(MethodWithoutParams), BindingFlags.Instance | BindingFlags.NonPublic)!;
             var methodWithoutParamsDelegate = (Action<IInvocation>)methodWithoutParams.CreateDelegate(typeof(Action<IInvocation>), this);
             methodMap.Add(method, methodWithoutParamsDelegate);
         }

src/Autofac.Extras.AggregateService/TypeExtensions.cs

@@ -25,11 +25,6 @@ public static IEnumerable<Type> GetUniqueInterfaces(this Type type)
         var types = new HashSet<Type>();
         foreach (var interfaceType in type.GetInterfaces())
         {
-            if (types.Contains(interfaceType))
-            {
-                continue;
-            }
-
             types.Add(interfaceType);
         }
 

test/Autofac.Extras.AggregateService.Test/AggregateServiceGeneratorTests.cs

@@ -17,6 +17,17 @@ public void CreateInstance_InterfaceType()
         Assert.IsAssignableFrom<IAggregateService>(instance);
     }
 
+    [Fact]
+    public void CreateInstance_NestedInterfaceType()
+    {
+        using var container = CreateContainer();
+
+        var instance = AggregateServiceGenerator.CreateInstance(typeof(INestedAggregateService), container);
+
+        var aggregateService = Assert.IsAssignableFrom<INestedAggregateService>(instance);
+        Assert.NotNull(aggregateService.MyService);
+    }
+
     [Fact]
     public void CreateInstance_NullComponentContext()
     {
@@ -51,4 +62,12 @@ private static IContainer CreateContainer()
         builder.RegisterInstance(Substitute.For<IMyService>());
         return builder.Build();
     }
+
+    public interface INestedAggregateService
+    {
+        IMyService MyService
+        {
+            get;
+        }
+    }
 }

test/Autofac.Extras.AggregateService.Test/GeneratedAggregateServiceRegistryTests.cs

@@ -0,0 +1,103 @@
+// Copyright (c) Autofac Project. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using NSubstitute;
+
+namespace Autofac.Extras.AggregateService.Test;
+
+public class GeneratedAggregateServiceRegistryTests
+{
+    [Fact]
+    public void Register_NullFactory()
+    {
+        Assert.Throws<ArgumentNullException>(() => GeneratedAggregateServiceRegistry.Register(typeof(IClosedAggregate), null!));
+    }
+
+    [Fact]
+    public void Register_NullInterfaceType()
+    {
+        Assert.Throws<ArgumentNullException>(() => GeneratedAggregateServiceRegistry.Register(null!, _ => new ClosedAggregate()));
+    }
+
+    [Fact]
+    public void RegisterOpenGeneric_NullBackingType()
+    {
+        Assert.Throws<ArgumentNullException>(() => GeneratedAggregateServiceRegistry.RegisterOpenGeneric(typeof(IOpenAggregate<>), null!));
+    }
+
+    [Fact]
+    public void RegisterOpenGeneric_NullInterfaceType()
+    {
+        Assert.Throws<ArgumentNullException>(() => GeneratedAggregateServiceRegistry.RegisterOpenGeneric(null!, typeof(OpenAggregate<>)));
+    }
+
+    [Fact]
+    public void TryCreate_ClosedFactoryRegistered()
+    {
+        var expected = new ClosedAggregate();
+        var context = Substitute.For<IComponentContext>();
+        GeneratedAggregateServiceRegistry.Register(typeof(IClosedAggregate), receivedContext =>
+        {
+            Assert.Same(context, receivedContext);
+            return expected;
+        });
+
+        var created = GeneratedAggregateServiceRegistry.TryCreate(typeof(IClosedAggregate), context, out var instance);
+
+        Assert.True(created);
+        Assert.Same(expected, instance);
+    }
+
+    [Fact]
+    public void TryCreate_NoRegisteredFactory()
+    {
+        var context = Substitute.For<IComponentContext>();
+
+        var created = GeneratedAggregateServiceRegistry.TryCreate(typeof(IUnregisteredAggregate), context, out var instance);
+
+        Assert.False(created);
+        Assert.Null(instance);
+    }
+
+    [Fact]
+    public void TryCreate_OpenGenericBackingRegistered()
+    {
+        var context = Substitute.For<IComponentContext>();
+        GeneratedAggregateServiceRegistry.RegisterOpenGeneric(typeof(IOpenAggregate<>), typeof(OpenAggregate<>));
+
+        var created = GeneratedAggregateServiceRegistry.TryCreate(typeof(IOpenAggregate<string>), context, out var instance);
+
+        var aggregate = Assert.IsType<OpenAggregate<string>>(instance);
+        Assert.True(created);
+        Assert.Same(context, aggregate.Context);
+    }
+
+    public interface IClosedAggregate
+    {
+    }
+
+    public interface IOpenAggregate<T>
+    {
+    }
+
+    public interface IUnregisteredAggregate
+    {
+    }
+
+    public sealed class ClosedAggregate : IClosedAggregate
+    {
+    }
+
+    public sealed class OpenAggregate<T> : IOpenAggregate<T>
+    {
+        public OpenAggregate(IComponentContext context)
+        {
+            Context = context;
+        }
+
+        public IComponentContext Context
+        {
+            get;
+        }
+    }
+}