fix: changed TestServiceProvider to validate scopes like Blazor's does. Closes #461

Author: egil

CHANGELOG.md

@@ -50,6 +50,7 @@ List of fixes in this release.
 ### Changed
 
 - Changed bunit.template such that created projects only reference the bUnit package. Bumped other referenced packages to latest version.
+- Changed TestServiceProvider to validate scopes of registered services, such that it behaves like the service provider (default IoC container) in Blazor.
 
 ## [1.0.16]
 

src/bunit.core/TestServiceProvider.cs

@@ -13,7 +13,9 @@ namespace Bunit
 	public sealed class TestServiceProvider : IServiceProvider, IServiceCollection, IDisposable
 	{
 		private readonly IServiceCollection serviceCollection;
-		private ServiceProvider? serviceProvider;
+		private IServiceProvider? rootServiceProvider;
+		private IServiceScope? serviceScope;
+		private IServiceProvider? serviceProvider;
 		private IServiceProvider? fallbackServiceProvider;
 
 		/// <summary>
@@ -85,7 +87,9 @@ public object GetService(Type serviceType)
 			if (serviceProvider is null)
 			{
 				serviceCollection.AddSingleton<TestServiceProvider>(this);
-				serviceProvider = serviceCollection.BuildServiceProvider();
+				rootServiceProvider = serviceCollection.BuildServiceProvider(validateScopes: true);
+				serviceScope = rootServiceProvider.CreateScope();
+				serviceProvider = serviceScope.ServiceProvider;
 			}
 
 			var result = serviceProvider.GetService(serviceType);
@@ -104,15 +108,11 @@ public object GetService(Type serviceType)
 
 		/// <inheritdoc/>
 		public void Dispose()
-		{
-			if (serviceProvider is null) return;
-
-			var disposedTask = serviceProvider.DisposeAsync().AsTask();
-
-			if (!disposedTask.IsCompleted)
-				disposedTask.GetAwaiter().GetResult();
-
-			serviceProvider.Dispose();
+		{			
+			(serviceScope as IAsyncDisposable)?.DisposeAsync().AsTask().GetAwaiter().GetResult();
+			serviceScope?.Dispose();
+			(rootServiceProvider as IAsyncDisposable)?.DisposeAsync().AsTask().GetAwaiter().GetResult();
+			(rootServiceProvider as IDisposable)?.Dispose();
 		}
 
 		/// <inheritdoc/>

tests/bunit.core.tests/TestServiceProviderTest.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.AspNetCore.Components;
 using Microsoft.Extensions.DependencyInjection;
 using Shouldly;
@@ -209,5 +210,51 @@ public void Test030()
 			// Act and assert
 			Should.NotThrow(() => ctx.RenderComponent<DummyComponentWhichRequiresDummyService>());
 		}
+
+		[Fact(DisplayName = "Can correctly resolve and dispose of scoped disposable service")]
+		public void Test031()
+		{
+			var sut = new TestServiceProvider();
+			sut.AddScoped<DisposableService>();
+			var disposable = sut.GetService<DisposableService>();
+
+			sut.Dispose();
+
+			disposable.IsDisposed.ShouldBeTrue();
+		}
+
+		[Fact(DisplayName = "Can correctly resolve and dispose of transient disposable service")]
+		public void Test032()
+		{
+			var sut = new TestServiceProvider();
+			sut.AddTransient<DisposableService>();
+			var disposable = sut.GetService<DisposableService>();
+
+			sut.Dispose();
+
+			disposable.IsDisposed.ShouldBeTrue();
+		}
+
+		[Fact(DisplayName = "Can correctly resolve and dispose of singleton disposable service")]
+		public void Test033()
+		{
+			var sut = new TestServiceProvider();
+			sut.AddSingleton<DisposableService>();
+			var disposable = sut.GetService<DisposableService>();
+
+			sut.Dispose();
+
+			disposable.IsDisposed.ShouldBeTrue();
+		}
+
+		private sealed class DisposableService : IDisposable
+		{
+			public bool IsDisposed { get; private set; }
+
+			public void Dispose()
+			{
+				IsDisposed = true;
+			}
+		}
 	}
 }

tests/bunit.core.tests/TestServiceProviderTest.net5.cs

@@ -1,6 +1,5 @@
-#if !NETCOREAPP3_1
+#if NET5_0_OR_GREATER
 using System;
-using System.Diagnostics.CodeAnalysis;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Shouldly;
@@ -10,20 +9,51 @@ namespace Bunit
 {
 	public partial class TestServiceProviderTest
 	{
-		[Fact(DisplayName = "Can correctly dispose of async disposable service")]
-		[SuppressMessage("Reliability", "CA2000:Dispose objects before losing scope", Justification = "Point of test is to verify explicit call to Dispose doesn't throw.")]
+		[Fact(DisplayName = "Can correctly resolve and dispose of scoped disposable service")]
 		public void Net5Test001()
 		{
 			var sut = new TestServiceProvider();
 			sut.AddScoped<AsyncDisposableService>();
-			sut.GetService<AsyncDisposableService>();
+			var asyncDisposable = sut.GetService<AsyncDisposableService>();
 
-			Should.NotThrow(() => sut.Dispose());
+			sut.Dispose();
+
+			asyncDisposable.IsDisposed.ShouldBeTrue();
+		}
+
+		[Fact(DisplayName = "Can correctly resolve and dispose of transient disposable service")]
+		public void Net5Test002()
+		{
+			var sut = new TestServiceProvider();
+			sut.AddTransient<AsyncDisposableService>();
+			var asyncDisposable = sut.GetService<AsyncDisposableService>();
+
+			sut.Dispose();
+
+			asyncDisposable.IsDisposed.ShouldBeTrue();
 		}
 
-		private class AsyncDisposableService : IAsyncDisposable
+		[Fact(DisplayName = "Can correctly resolve and dispose of singleton disposable service")]
+		public void Net5Test003()
 		{
-			public ValueTask DisposeAsync() => ValueTask.CompletedTask;
+			var sut = new TestServiceProvider();
+			sut.AddSingleton<AsyncDisposableService>();
+			var asyncDisposable = sut.GetService<AsyncDisposableService>();
+
+			sut.Dispose();
+
+			asyncDisposable.IsDisposed.ShouldBeTrue();
+		}
+
+		private sealed class AsyncDisposableService : IAsyncDisposable
+		{
+			public bool IsDisposed { get; private set; }
+
+			public ValueTask DisposeAsync()
+			{
+				IsDisposed = true;
+				return ValueTask.CompletedTask;
+			}
 		}
 	}
 }