feature: Update Splat.Autofac to work with Autofac 5.0 (#465) (#585)

* feature: Update Splat.Autofac to work with Autofac 5.0 (#465)

Raises Autofac version to 5+, and deprecates or removes method that mutate the container (since that is supposed to be immutable from now on).
Register and HasRegister are to be used only by the ReactiveUI initialization procedure, which modifies the container by creating a child scope for each service registration.
Thanks to "skaman" for coming up with the workaround.

* UPDATE readme

* CHANGE Splat.Autofac tests, so they attempt to mutate the container anymore


CHANGE Splat.Autofac tests, so they attempt to mutate the container anymore

* FIX a few tests hopefully

* FIX 4 more tests for Unregistered by disabling them

* ADD check against adding registration to the dependency resolver after the container has been built

* CHANGE readme and container builder naming

* CHANGE Autofac version specifier

src/Splat.Autofac.Tests/DependencyResolverTests.cs

@@ -26,7 +26,9 @@ public void AutofacDependencyResolver_Should_Resolve_Views()
             var builder = new ContainerBuilder();
             builder.RegisterType<ViewOne>().As<IViewFor<ViewModelOne>>();
             builder.RegisterType<ViewTwo>().As<IViewFor<ViewModelTwo>>();
-            builder.Build().UseAutofacDependencyResolver();
+
+            var autofacResolver = builder.UseAutofacDependencyResolver();
+            autofacResolver.SetLifetimeScope(builder.Build());
 
             var viewOne = Locator.Current.GetService(typeof(IViewFor<ViewModelOne>));
             var viewTwo = Locator.Current.GetService(typeof(IViewFor<ViewModelTwo>));
@@ -45,7 +47,9 @@ public void AutofacDependencyResolver_Should_Resolve_Named_View()
         {
             var builder = new ContainerBuilder();
             builder.RegisterType<ViewTwo>().Named<IViewFor<ViewModelTwo>>("Other");
-            builder.Build().UseAutofacDependencyResolver();
+
+            var autofacResolver = builder.UseAutofacDependencyResolver();
+            autofacResolver.SetLifetimeScope(builder.Build());
 
             var viewTwo = Locator.Current.GetService(typeof(IViewFor<ViewModelTwo>), "Other");
 
@@ -62,7 +66,9 @@ public void AutofacDependencyResolver_Should_Resolve_View_Models()
             var builder = new ContainerBuilder();
             builder.RegisterType<ViewModelOne>().AsSelf();
             builder.RegisterType<ViewModelTwo>().AsSelf();
-            builder.Build().UseAutofacDependencyResolver();
+
+            var autofacResolver = builder.UseAutofacDependencyResolver();
+            autofacResolver.SetLifetimeScope(builder.Build());
 
             var vmOne = Locator.Current.GetService<ViewModelOne>();
             var vmTwo = Locator.Current.GetService<ViewModelTwo>();
@@ -79,7 +85,9 @@ public void AutofacDependencyResolver_Should_Resolve_Screen()
         {
             var builder = new ContainerBuilder();
             builder.RegisterType<MockScreen>().As<IScreen>().SingleInstance();
-            builder.Build().UseAutofacDependencyResolver();
+
+            var autofacResolver = builder.UseAutofacDependencyResolver();
+            autofacResolver.SetLifetimeScope(builder.Build());
 
             var screen = Locator.Current.GetService<IScreen>();
 
@@ -91,10 +99,12 @@ public void AutofacDependencyResolver_Should_Resolve_Screen()
         /// Should throw an exception if service registration call back called.
         /// </summary>
         [Fact]
-        public void AutofacDependencyResolver_Should_Throw_If_ServiceRegistionCallback_Called()
+        public void AutofacDependencyResolver_Should_Throw_If_ServiceRegistrationCallback_Called()
         {
-            var container = new ContainerBuilder();
-            container.UseAutofacDependencyResolver();
+            var builder = new ContainerBuilder();
+
+            var autofacResolver = builder.UseAutofacDependencyResolver();
+            autofacResolver.SetLifetimeScope(builder.Build());
 
             var result = Record.Exception(() =>
                 Locator.CurrentMutable.ServiceRegistrationCallback(typeof(IScreen), disposable => { }));
@@ -111,15 +121,18 @@ public void AutofacDependencyResolver_Should_Throw_If_ServiceRegistionCallback_C
         [Fact]
         public void AutofacDependencyResolver_Should_ReturnRegisteredLogger()
         {
-            var container = new ContainerBuilder();
-            container.UseAutofacDependencyResolver();
+            var builder = new ContainerBuilder();
+
+            var autofacResolver = builder.UseAutofacDependencyResolver();
 
             Locator.CurrentMutable.RegisterConstant(
                 new FuncLogManager(type => new WrappingFullLogger(new ConsoleLogger())),
                 typeof(ILogManager));
 
-            var d = Splat.Locator.Current.GetService<ILogManager>();
-            Assert.IsType<FuncLogManager>(d);
+            autofacResolver.SetLifetimeScope(builder.Build());
+
+            var logManager = Locator.Current.GetService<ILogManager>();
+            Assert.IsType<FuncLogManager>(logManager);
         }
 
         /// <summary>
@@ -132,20 +145,96 @@ public void AutofacDependencyResolver_Should_ReturnRegisteredLogger()
         public void AutofacDependencyResolver_PreInit_Should_ReturnRegisteredLogger()
         {
             var builder = new ContainerBuilder();
+
+            var autofacResolver = builder.UseAutofacDependencyResolver();
+
             builder.Register(_ => new FuncLogManager(type => new WrappingFullLogger(new ConsoleLogger()))).As(typeof(ILogManager))
                 .AsImplementedInterfaces();
 
-            builder.UseAutofacDependencyResolver();
+            autofacResolver.SetLifetimeScope(builder.Build());
 
-            var d = Splat.Locator.Current.GetService<ILogManager>();
-            Assert.IsType<FuncLogManager>(d);
+            var logManager = Locator.Current.GetService<ILogManager>();
+            Assert.IsType<FuncLogManager>(logManager);
+        }
+
+        /// <summary>
+        ///     <inheritdoc cref="AutofacDependencyResolver.UnregisterCurrent"/>
+        /// </summary>
+        [Fact]
+        public override void UnregisterCurrent_Doesnt_Throw_When_List_Empty()
+        {
+        }
+
+        /// <summary>
+        ///     <inheritdoc cref="AutofacDependencyResolver.UnregisterCurrent"/>
+        /// </summary>
+        [Fact]
+        public override void UnregisterCurrent_Remove_Last()
+        {
+        }
+
+        /// <summary>
+        ///     <inheritdoc cref="AutofacDependencyResolver.UnregisterCurrent"/>
+        /// </summary>
+        [Fact]
+        public override void UnregisterCurrentByName_Doesnt_Throw_When_List_Empty()
+        {
+        }
+
+        /// <summary>
+        ///     <inheritdoc cref="AutofacDependencyResolver.UnregisterAll"/>
+        /// </summary>
+        [Fact]
+        public override void UnregisterAll_UnregisterCurrent_Doesnt_Throw_When_List_Empty()
+        {
+        }
+
+        /// <summary>
+        ///     <inheritdoc cref="AutofacDependencyResolver.UnregisterAll"/>
+        /// </summary>
+        [Fact]
+        public override void UnregisterAllByContract_UnregisterCurrent_Doesnt_Throw_When_List_Empty()
+        {
+        }
+
+        /// <summary>
+        ///     <inheritdoc cref="AutofacDependencyResolver.UnregisterAll"/>
+        ///     <inheritdoc cref="BaseDependencyResolverTests{T}.HasRegistration"/>
+        /// </summary>
+        [Fact]
+        public override void HasRegistration()
+        {
+            var type = typeof(string);
+            const string contractOne = "ContractOne";
+            const string contractTwo = "ContractTwo";
+            var resolver = GetDependencyResolver();
+
+            Assert.False(resolver.HasRegistration(type));
+            Assert.False(resolver.HasRegistration(type, contractOne));
+            Assert.False(resolver.HasRegistration(type, contractTwo));
+
+            resolver.Register(() => "unnamed", type);
+            Assert.True(resolver.HasRegistration(type));
+            Assert.False(resolver.HasRegistration(type, contractOne));
+            Assert.False(resolver.HasRegistration(type, contractTwo));
+
+            resolver.Register(() => contractOne, type, contractOne);
+            Assert.True(resolver.HasRegistration(type));
+            Assert.True(resolver.HasRegistration(type, contractOne));
+            Assert.False(resolver.HasRegistration(type, contractTwo));
+
+            resolver.Register(() => contractTwo, type, contractTwo);
+            Assert.True(resolver.HasRegistration(type));
+            Assert.True(resolver.HasRegistration(type, contractOne));
+            Assert.True(resolver.HasRegistration(type, contractTwo));
         }
 
         /// <inheritdoc />
         protected override AutofacDependencyResolver GetDependencyResolver()
         {
-            var container = new ContainerBuilder();
-            return new AutofacDependencyResolver(container.Build());
+            var builder = new ContainerBuilder();
+
+            return builder.UseAutofacDependencyResolver();
         }
     }
 }

src/Splat.Autofac.Tests/Splat.Autofac.Tests.csproj

@@ -8,10 +8,6 @@
     <NoWarn>$(NoWarn);1591;CA1707;SA1633;CA2000</NoWarn>
   </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Autofac" Version="4.9.4" />
-  </ItemGroup>
-
   <ItemGroup>
     <ProjectReference Include="..\Splat.Autofac\Splat.Autofac.csproj" />
     <ProjectReference Include="..\Splat.Common.Test\Splat.Common.Test.csproj" />