Adding support for constrained open generics

src/DependencyInjection/DI.External.Tests/test/Autofac.cs

@@ -7,9 +7,14 @@
 
 namespace Microsoft.Extensions.DependencyInjection.Specification
 {
-    public class AutofacDependencyInjectionSpecificationTests: DependencyInjectionSpecificationTests
+    public class AutofacDependencyInjectionSpecificationTests: SkippableDependencyInjectionSpecificationTests
     {
-        protected override IServiceProvider CreateServiceProvider(IServiceCollection serviceCollection)
+        public override string[] SkippedTests => new[]
+        {
+            "PublicNoArgCtorConstrainedOpenGenericServicesCanBeResolved"
+        };
+
+        protected override IServiceProvider CreateServiceProviderImpl(IServiceCollection serviceCollection)
         {
             var builder = new ContainerBuilder();
             builder.Populate(serviceCollection);

src/DependencyInjection/DI.External.Tests/test/StashBox.cs

@@ -5,9 +5,16 @@
 
 namespace Microsoft.Extensions.DependencyInjection.Specification
 {
-    public class StashBoxDependencyInjectionSpecificationTests: DependencyInjectionSpecificationTests
+    public class StashBoxDependencyInjectionSpecificationTests: SkippableDependencyInjectionSpecificationTests
     {
-        protected override IServiceProvider CreateServiceProvider(IServiceCollection serviceCollection)
+        public override string[] SkippedTests => new[]
+        {
+            "PublicNoArgCtorConstrainedOpenGenericServicesCanBeResolved",
+            "SelfReferencingConstrainedOpenGenericServicesCanBeResolved",
+            "ClassConstrainedOpenGenericServicesCanBeResolved"
+        };
+
+        protected override IServiceProvider CreateServiceProviderImpl(IServiceCollection serviceCollection)
         {
             return serviceCollection.UseStashbox();
         }

src/DependencyInjection/DI.Specification.Tests/src/DependencyInjectionSpecificationTests.cs

@@ -545,6 +545,160 @@ public void OpenGenericServicesCanBeResolved()
             Assert.Same(singletonService, genericService.Value);
         }
 
+        [Fact]
+        public void ConstrainedOpenGenericServicesCanBeResolved()
+        {
+            // Arrange
+            var collection = new TestServiceCollection();
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(FakeOpenGenericService<>));
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(ConstrainedFakeOpenGenericService<>));
+            var poco = new PocoClass();
+            collection.AddSingleton(poco);
+            collection.AddSingleton<IFakeSingletonService, FakeService>();
+            var provider = CreateServiceProvider(collection);
+            // Act
+            var allServices = provider.GetServices<IFakeOpenGenericService<PocoClass>>().ToList();
+            var constrainedServices = provider.GetServices<IFakeOpenGenericService<IFakeSingletonService>>().ToList();
+            var singletonService = provider.GetService<IFakeSingletonService>();
+            // Assert
+            Assert.Equal(2, allServices.Count);
+            Assert.Same(poco, allServices[0].Value);
+            Assert.Same(poco, allServices[1].Value);
+            Assert.Equal(1, constrainedServices.Count);
+            Assert.Same(singletonService, constrainedServices[0].Value);
+        }
+
+        [Fact]
+        public void ConstrainedOpenGenericServicesReturnsEmptyWithNoMatches()
+        {
+            // Arrange
+            var collection = new TestServiceCollection();
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(ConstrainedFakeOpenGenericService<>));
+            collection.AddSingleton<IFakeSingletonService, FakeService>();
+            var provider = CreateServiceProvider(collection);
+            // Act
+            var constrainedServices = provider.GetServices<IFakeOpenGenericService<IFakeSingletonService>>().ToList();
+            // Assert
+            Assert.Equal(0, constrainedServices.Count);
+        }
+
+        [Fact]
+        public void InterfaceConstrainedOpenGenericServicesCanBeResolved()
+        {
+            // Arrange
+            var collection = new TestServiceCollection();
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(FakeOpenGenericService<>));
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(ClassWithInterfaceConstraint<>));
+            var enumerableVal = new ClassImplementingIEnumerable();
+            collection.AddSingleton(enumerableVal);
+            collection.AddSingleton<IFakeSingletonService, FakeService>();
+            var provider = CreateServiceProvider(collection);
+            // Act
+            var allServices = provider.GetServices<IFakeOpenGenericService<ClassImplementingIEnumerable>>().ToList();
+            var constrainedServices = provider.GetServices<IFakeOpenGenericService<IFakeSingletonService>>().ToList();
+            var singletonService = provider.GetService<IFakeSingletonService>();
+            // Assert
+            Assert.Equal(2, allServices.Count);
+            Assert.Same(enumerableVal, allServices[0].Value);
+            Assert.Same(enumerableVal, allServices[1].Value);
+            Assert.Equal(1, constrainedServices.Count);
+            Assert.Same(singletonService, constrainedServices[0].Value);
+        }
+
+        [Fact]
+        public void PublicNoArgCtorConstrainedOpenGenericServicesCanBeResolved()
+        {
+            // Arrange
+            var collection = new TestServiceCollection();
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(ClassWithNoConstraints<>));
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(ClassWithNewConstraint<>));
+            var provider = CreateServiceProvider(collection);
+            // Act
+            var allServices = provider.GetServices<IFakeOpenGenericService<PocoClass>>().ToList();
+            var constrainedServices = provider.GetServices<IFakeOpenGenericService<ClassWithPrivateCtor>>().ToList();
+            // Assert
+            Assert.Equal(2, allServices.Count);
+            Assert.Equal(1, constrainedServices.Count);
+        }
+
+        [Fact]
+        public void ClassConstrainedOpenGenericServicesCanBeResolved()
+        {
+            // Arrange
+            var collection = new TestServiceCollection();
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(ClassWithNoConstraints<>));
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(ClassWithClassConstraint<>));
+            var provider = CreateServiceProvider(collection);
+            // Act
+            var allServices = provider.GetServices<IFakeOpenGenericService<PocoClass>>().ToList();
+            var constrainedServices = provider.GetServices<IFakeOpenGenericService<int>>().ToList();
+            // Assert
+            Assert.Equal(2, allServices.Count);
+            Assert.Equal(1, constrainedServices.Count);
+        }
+
+        [Fact]
+        public void StructConstrainedOpenGenericServicesCanBeResolved()
+        {
+            // Arrange
+            var collection = new TestServiceCollection();
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(ClassWithNoConstraints<>));
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(ClassWithStructConstraint<>));
+            var provider = CreateServiceProvider(collection);
+            // Act
+            var allServices = provider.GetServices<IFakeOpenGenericService<int>>().ToList();
+            var constrainedServices = provider.GetServices<IFakeOpenGenericService<PocoClass>>().ToList();
+            // Assert
+            Assert.Equal(2, allServices.Count);
+            Assert.Equal(1, constrainedServices.Count);
+        }
+
+        [Fact]
+        public void AbstractClassConstrainedOpenGenericServicesCanBeResolved()
+        {
+            // Arrange
+            var collection = new TestServiceCollection();
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(FakeOpenGenericService<>));
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(ClassWithAbstractClassConstraint<>));
+            var poco = new PocoClass();
+            collection.AddSingleton(poco);
+            var classInheritingClassInheritingAbstractClass = new ClassInheritingClassInheritingAbstractClass();
+            collection.AddSingleton(classInheritingClassInheritingAbstractClass);
+            var provider = CreateServiceProvider(collection);
+            // Act
+            var allServices = provider.GetServices<IFakeOpenGenericService<ClassInheritingClassInheritingAbstractClass>>().ToList();
+            var constrainedServices = provider.GetServices<IFakeOpenGenericService<PocoClass>>().ToList();
+            // Assert
+            Assert.Equal(2, allServices.Count);
+            Assert.Same(classInheritingClassInheritingAbstractClass, allServices[0].Value);
+            Assert.Same(classInheritingClassInheritingAbstractClass, allServices[1].Value);
+            Assert.Equal(1, constrainedServices.Count);
+            Assert.Same(poco, constrainedServices[0].Value);
+        }
+
+        [Fact]
+        public void SelfReferencingConstrainedOpenGenericServicesCanBeResolved()
+        {
+            // Arrange
+            var collection = new TestServiceCollection();
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(FakeOpenGenericService<>));
+            collection.AddTransient(typeof(IFakeOpenGenericService<>), typeof(ClassWithSelfReferencingConstraint<>));
+            var poco = new PocoClass();
+            collection.AddSingleton(poco);
+            var selfComparable = new ClassImplementingIComparable();
+            collection.AddSingleton(selfComparable);
+            var provider = CreateServiceProvider(collection);
+            // Act
+            var allServices = provider.GetServices<IFakeOpenGenericService<ClassImplementingIComparable>>().ToList();
+            var constrainedServices = provider.GetServices<IFakeOpenGenericService<PocoClass>>().ToList();
+            // Assert
+            Assert.Equal(2, allServices.Count);
+            Assert.Same(selfComparable, allServices[0].Value);
+            Assert.Same(selfComparable, allServices[1].Value);
+            Assert.Equal(1, constrainedServices.Count);
+            Assert.Same(poco, constrainedServices[0].Value);
+        }
+
         [Fact]
         public void ClosedServicesPreferredOverOpenGenericServices()
         {

src/DependencyInjection/DI/test/Fakes/AbstractClass.cs → src/DependencyInjection/DI.Specification.Tests/src/Fakes/AbstractClass.cs

@@ -1,12 +1,9 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
-namespace Microsoft.Extensions.DependencyInjection.Tests.Fakes
+namespace Microsoft.Extensions.DependencyInjection.Specification.Fakes
 {
     public abstract class AbstractClass
     {
-        public AbstractClass()
-        {
-        }
     }
 }

src/DependencyInjection/DI.Specification.Tests/src/Fakes/ClassImplementingIComparable.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Microsoft.Extensions.DependencyInjection.Specification.Fakes
+{
+    public class ClassImplementingIComparable : IComparable<ClassImplementingIComparable>
+    {
+        public int CompareTo(ClassImplementingIComparable other) => 0;
+    }
+}

src/DependencyInjection/DI.Specification.Tests/src/Fakes/ClassImplementingIEnumerable.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections;
+
+namespace Microsoft.Extensions.DependencyInjection.Specification.Fakes
+{
+    public class ClassImplementingIEnumerable : IEnumerable
+    {
+        public IEnumerator GetEnumerator() => throw new NotImplementedException();
+    }
+}

src/DependencyInjection/DI.Specification.Tests/src/Fakes/ClassInheritingAbstractClass.cs

@@ -0,0 +1,20 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.Extensions.DependencyInjection.Specification.Fakes
+{
+    public class ClassInheritingAbstractClass : AbstractClass
+    {
+
+    }
+
+    public class ClassAlsoInheritingAbstractClass : AbstractClass
+    {
+
+    }
+
+    public class ClassInheritingClassInheritingAbstractClass : ClassInheritingAbstractClass
+    {
+
+    }
+}

src/DependencyInjection/DI.Specification.Tests/src/Fakes/ClassWithAbstractClassConstraint.cs

@@ -0,0 +1,13 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.Extensions.DependencyInjection.Specification.Fakes
+{
+    public class ClassWithAbstractClassConstraint<T> : IFakeOpenGenericService<T>
+        where T : AbstractClass
+    {
+        public ClassWithAbstractClassConstraint(T value) => Value = value;
+
+        public T Value { get; }
+    }
+}

src/DependencyInjection/DI.Specification.Tests/src/Fakes/ClassWithClassConstraint.cs

@@ -0,0 +1,11 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.Extensions.DependencyInjection.Specification.Fakes
+{
+    public class ClassWithClassConstraint<T> : IFakeOpenGenericService<T>
+        where T : class
+    {
+        public T Value { get; } = default;
+    }
+}

src/DependencyInjection/DI.Specification.Tests/src/Fakes/ClassWithInterfaceConstraint.cs

@@ -0,0 +1,13 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+using System.Collections;
+namespace Microsoft.Extensions.DependencyInjection.Specification.Fakes
+{
+    public class ClassWithInterfaceConstraint<T> : IFakeOpenGenericService<T>
+        where T : IEnumerable
+    {
+        public ClassWithInterfaceConstraint(T value) => Value = value;
+
+        public T Value { get; }
+    }
+}

src/DependencyInjection/DI.Specification.Tests/src/Fakes/ClassWithNewConstraint.cs

@@ -0,0 +1,11 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.Extensions.DependencyInjection.Specification.Fakes
+{
+    public class ClassWithNewConstraint<T> : IFakeOpenGenericService<T>
+        where T : new()
+    {
+        public T Value { get; } = new T();
+    }
+}

src/DependencyInjection/DI.Specification.Tests/src/Fakes/ClassWithNoConstraints.cs

@@ -0,0 +1,7 @@
+namespace Microsoft.Extensions.DependencyInjection.Specification.Fakes
+{
+    public class ClassWithNoConstraints<T> : IFakeOpenGenericService<T>
+    {
+        public T Value { get; } = default;
+    }
+}

src/DependencyInjection/DI.Specification.Tests/src/Fakes/ClassWithSelfReferencingConstraint.cs

@@ -0,0 +1,15 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.Extensions.DependencyInjection.Specification.Fakes
+{
+    public class ClassWithSelfReferencingConstraint<T> : IFakeOpenGenericService<T>
+        where T : IComparable<T>
+    {
+        public ClassWithSelfReferencingConstraint(T value) => Value = value;
+
+        public T Value { get; }
+    }
+}

src/DependencyInjection/DI.Specification.Tests/src/Fakes/ClassWithStructConstraint.cs

@@ -0,0 +1,11 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.Extensions.DependencyInjection.Specification.Fakes
+{
+    public class ClassWithStructConstraint<T> : IFakeOpenGenericService<T>
+        where T : struct
+    {
+        public T Value { get; } = default;
+    }
+}

src/DependencyInjection/DI.Specification.Tests/src/Fakes/ConstrainedFakeOpenGenericService.cs

@@ -0,0 +1,14 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+namespace Microsoft.Extensions.DependencyInjection.Specification.Fakes
+{
+    public class ConstrainedFakeOpenGenericService<TVal> : IFakeOpenGenericService<TVal>
+        where TVal : PocoClass
+    {
+        public ConstrainedFakeOpenGenericService(TVal value)
+        {
+            Value = value;
+        }
+        public TVal Value { get; }
+    }
+}

src/DependencyInjection/DI.Specification.Tests/src/Fakes/IFakeOpenGenericService.cs

@@ -3,7 +3,7 @@
 
 namespace Microsoft.Extensions.DependencyInjection.Specification.Fakes
 {
-    public interface IFakeOpenGenericService<TValue>
+    public interface IFakeOpenGenericService<out TValue>
     {
         TValue Value { get; }
     }