first commit

Nitrox.Test/Model/Core/DependencyInjectionTests.cs

@@ -0,0 +1,148 @@
+using Autofac;
+
+namespace NitroxModel.Core;
+
+[TestClass]
+public class DependencyInjectionTests
+{
+    [TestInitialize]
+    public void Init()
+    {
+        NitroxServiceLocator.InitializeDependencyContainer(new DependencyInjectionTestsAutoFacRegistrar());
+        NitroxServiceLocator.BeginNewLifetimeScope();
+    }
+
+    [TestMethod]
+    public void ShouldResolveDependencyPolymorphically()
+    {
+        // Arrange
+        IRootDependency polymorphicallyResolvedDependency = NitroxServiceLocator.LocateService<IRootDependency>();
+
+        // Assert
+        polymorphicallyResolvedDependency.Should().NotBeNull();
+        polymorphicallyResolvedDependency.Should().BeOfType<RootDependency>();
+    }
+
+    [TestMethod]
+    public void ShouldResolveConcreteType()
+    {
+        // Arrange
+        DependencyWithRootDependency directConcreteTypeDependency = NitroxServiceLocator.LocateService<DependencyWithRootDependency>();
+
+        // Assert
+        directConcreteTypeDependency.Should().NotBeNull();
+        directConcreteTypeDependency.RootDependency.Should().NotBeNull();
+        directConcreteTypeDependency.RootDependency.Should().BeOfType<RootDependency>();
+    }
+
+    [TestMethod]
+    public void ShouldResolveGenericDependencies()
+    {
+        // Arrange
+        IServicer<ServiceRecipientA> servicerA = NitroxServiceLocator.LocateService<IServicer<ServiceRecipientA>>();
+        IServicer<ServiceRecipientB> servicerB = NitroxServiceLocator.LocateService<IServicer<ServiceRecipientB>>();
+
+        // Assert
+        servicerA.Should().NotBeNull();
+        servicerA.Should().BeOfType<ServiceAProvider>();
+        Invoking(() => servicerA.PerformService(null)).Should().Throw<NotImplementedException>();
+
+        servicerB.Should().NotBeNull();
+        servicerB.Should().BeOfType<ServiceBProvider>();
+        Invoking(() => servicerB.PerformService(null)).Should().Throw<NotImplementedException>();
+    }
+
+    [TestMethod]
+    public void ShouldResolveGenericDependenciesFromManuallyConstructedTypeInstances()
+    {
+        // Arrange
+        Type servicerInstanceType = typeof(IServicer<>);
+        Type recipientAType = typeof(ServiceRecipientA);
+        Type recipientBType = typeof(ServiceRecipientB);
+        Type servicerAType = servicerInstanceType.MakeGenericType(recipientAType);
+        Type servicerBType = servicerInstanceType.MakeGenericType(recipientBType);
+
+        // Act
+        IServicer<ServiceRecipientA> servicerA = (BaseServiceProvider<ServiceRecipientA>)NitroxServiceLocator.LocateService(servicerAType);
+        IServicer<ServiceRecipientB> servicerB = (BaseServiceProvider<ServiceRecipientB>)NitroxServiceLocator.LocateService(servicerBType);
+
+        // Assert
+        servicerA.Should().NotBeNull();
+        servicerA.Should().BeOfType<ServiceAProvider>();
+        Invoking(() => servicerA.PerformService(null)).Should().Throw<NotImplementedException>();
+
+        servicerB.Should().NotBeNull();
+        servicerB.Should().BeOfType<ServiceBProvider>();
+        Invoking(() => servicerB.PerformService(null)).Should().Throw<NotImplementedException>();
+    }
+
+    private class DependencyInjectionTestsAutoFacRegistrar : IAutoFacRegistrar
+    {
+        public void RegisterDependencies(ContainerBuilder containerBuilder)
+        {
+            containerBuilder.RegisterType<RootDependency>().As<IRootDependency>();
+            containerBuilder.RegisterType<DependencyWithRootDependency>();
+
+            containerBuilder.RegisterAssemblyTypes(Assembly.GetAssembly(GetType()))
+                .AsClosedTypesOf(typeof(IServicer<>));
+        }
+    }
+}
+
+public interface IRootDependency
+{
+}
+
+public class RootDependency : IRootDependency
+{
+}
+
+public class DependencyWithRootDependency
+{
+    public IRootDependency RootDependency { get; }
+
+    public DependencyWithRootDependency(IRootDependency rootDependency)
+    {
+        RootDependency = rootDependency;
+    }
+}
+
+public interface IServiced
+{
+}
+
+public interface IServicer<T>
+    where T : IServiced
+{
+    void PerformService(T serviced);
+}
+
+public class ServiceRecipientA : IServiced
+{
+}
+
+public class ServiceRecipientB : IServiced
+{
+}
+
+public abstract class BaseServiceProvider<TServiced> : IServicer<TServiced>
+    where TServiced : IServiced
+{
+    public abstract void PerformService(TServiced serviced);
+}
+
+public class ServiceAProvider : BaseServiceProvider<ServiceRecipientA>
+{
+    public override void PerformService(ServiceRecipientA serviced)
+    {
+        throw new NotImplementedException();
+    }
+}
+
+public class ServiceBProvider : BaseServiceProvider<ServiceRecipientB>
+{
+    public override void PerformService(ServiceRecipientB serviced)
+    {
+        throw new NotImplementedException();
+    }
+}