refactor: Move from moq to NSubstitute

linkdotnet · linkdotnet · commit 28f09e73ca95 · 2023-08-11T23:14:33.000+02:00
diff --git a/tests/Directory.Build.props b/tests/Directory.Build.props
@@ -18,7 +18,7 @@
 		<PackageReference Include="AutoFixture" Version="4.18.0" />
 		<PackageReference Include="AutoFixture.Xunit2" Version="4.18.0" />
 		<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.3" />
-		<PackageReference Include="Moq" Version="4.18.4" />
+		<PackageReference Include="NSubstitute" Version="5.0.0" />
 		<PackageReference Include="Shouldly" Version="4.2.1" />
 		<PackageReference Include="xunit" Version="2.5.0" />
 		<PackageReference Include="Xunit.Combinatorial" Version="1.5.25" />
@@ -39,7 +39,7 @@
 		<Using Include="Microsoft.AspNetCore.Components.Web" />
 		<Using Include="Microsoft.AspNetCore.Components.Routing" />
 		<Using Include="System.Reflection" />
-		<Using Include="Moq" />
+		<Using Include="NSubstitute" />
 		<Using Include="Shouldly" />
 		<Using Include="Xunit" />
 		<Using Include="Xunit.Abstractions" />
diff --git a/tests/bunit.core.tests/ComponentFactories/ConditionalComponentFactoryTest.cs b/tests/bunit.core.tests/ComponentFactories/ConditionalComponentFactoryTest.cs
@@ -22,7 +22,7 @@ public void Test003()
 	[Fact(DisplayName = "Component is replaced in render tree with component from factory when matches returns true")]
 	public void Test010()
 	{
-		var mockComponent = Mock.Of<Simple1>();
+		var mockComponent = Substitute.For<Simple1>();
 		ComponentFactories.Add(type => type == typeof(Simple1), _ => mockComponent);
 
 		var cut = RenderComponent<Wrapper>(ps => ps.AddChildContent<Simple1>());
@@ -34,17 +34,21 @@ public void Test010()
 	[Fact(DisplayName = "Component is replaced in render tree with component from factory when matches returns true")]
 	public void Test011()
 	{
-		var mockRepo = new MockRepository(MockBehavior.Loose);
+		var mockSimple1 = Substitute.For<Simple1>();
+		var mockNoArgs = Substitute.For<NoArgs>();
 		ComponentFactories.Add(
 			type => type != typeof(TwoComponentWrapper),
-			mockRepo.CreateComponent);
+			type => CreateComponent(type, mockSimple1, mockNoArgs)
+		);
 
+		// Act
 		var cut = RenderComponent<TwoComponentWrapper>(ps => ps
-		   .Add<Simple1>(p => p.First)
-		   .Add<NoArgs>(p => p.Second));
+			.Add<Simple1>(p => p.First)
+			.Add<NoArgs>(p => p.Second));
 
-		cut.FindComponents<Simple1>().ShouldAllBe(x => Mock.Get(x.Instance));
-		cut.FindComponents<NoArgs>().ShouldAllBe(x => Mock.Get(x.Instance));
+		// Assert
+		cut.FindComponents<Simple1>().ShouldAllBe(x => x.Instance == mockSimple1);
+		cut.FindComponents<NoArgs>().ShouldAllBe(x => x.Instance == mockNoArgs);
 	}
 
 	[Fact(DisplayName = "When matches returns false, factory is never called")]
@@ -54,19 +58,12 @@ public void Test012()
 
 		Should.NotThrow(() => RenderComponent<Wrapper>(ps => ps.AddChildContent<Simple1>()));
 	}
-}
-
-internal static class MockRepositoryExtensions
-{
-	private static readonly MethodInfo CreateMethodInfo = typeof(MockRepository)
-		.GetMethod(nameof(MockRepository.Create), Array.Empty<Type>());
-
-	public static IComponent CreateComponent(this MockRepository repository, Type type)
+	
+	private static IComponent CreateComponent(Type type, Simple1 simple1, NoArgs noArgs)
 	{
-		var genericCreateMethod = CreateMethodInfo.MakeGenericMethod(type);
-		var mock = (Mock)genericCreateMethod.Invoke(repository, null);
-		return (IComponent)mock.Object;
+		if (type == typeof(Simple1)) return simple1;
+		if (type == typeof(NoArgs)) return noArgs;
+		throw new NotImplementedException($"No mock implementation provided for type {type.FullName}");
 	}
 }
-
 #endif
diff --git a/tests/bunit.core.tests/ComponentFactories/InstanceComponentFactoryTest.cs b/tests/bunit.core.tests/ComponentFactories/InstanceComponentFactoryTest.cs
@@ -15,20 +15,20 @@ public void Test002()
 	[Fact(DisplayName = "Factory replaces one TComponent with instance in the render tree")]
 	public void Test010()
 	{
-		var simple1Mock = new Mock<Simple1>();
-		ComponentFactories.Add<Simple1>(simple1Mock.Object);
+		var simple1Mock = Substitute.For<Simple1>();
+		ComponentFactories.Add(simple1Mock);
 
 		var cut = RenderComponent<Wrapper>(ps => ps.AddChildContent<Simple1>());
 
 		cut.FindComponent<Simple1>()
-			.Instance.ShouldBeSameAs(simple1Mock.Object);
+			.Instance.ShouldBeSameAs(simple1Mock);
 	}
 
 	[Fact(DisplayName = "Factory throws if component instance is requested twice for TComponent that inherits from ComponentBase")]
 	public void Test020()
 	{
-		var simple1Mock = new Mock<Simple1>();
-		ComponentFactories.Add<Simple1>(simple1Mock.Object);
+		var simple1Mock = Substitute.For<Simple1>();
+		ComponentFactories.Add(simple1Mock);
 
 		Should.Throw<InvalidOperationException>(() => RenderComponent<TwoComponentWrapper>(ps => ps
 			   .Add<Simple1>(p => p.First)
@@ -38,8 +38,8 @@ public void Test020()
 	[Fact(DisplayName = "Factory throws if component instance is requested twice for TComponent that implements from IComponent")]
 	public void Test021()
 	{
-		var simple1Mock = new Mock<BasicComponent>();
-		ComponentFactories.Add<BasicComponent>(simple1Mock.Object);
+		var simple1Mock = Substitute.For<BasicComponent>();
+		ComponentFactories.Add(simple1Mock);
 
 		Should.Throw<InvalidOperationException>(() => RenderComponent<TwoComponentWrapper>(ps => ps
 			.Add<BasicComponent>(p => p.First)
diff --git a/tests/bunit.core.tests/ComponentFactories/TypeBasedComponentFactoryTest.cs b/tests/bunit.core.tests/ComponentFactories/TypeBasedComponentFactoryTest.cs
@@ -16,7 +16,7 @@ public void Test002()
 	[Fact(DisplayName = "TComponent replaced in render tree with component from factory method")]
 	public void Test010()
 	{
-		var simple1Mock = Mock.Of<Simple1>();
+		var simple1Mock = Substitute.For<Simple1>();
 		ComponentFactories.Add<Simple1>(() => simple1Mock);
 
 		var cut = RenderComponent<Wrapper>(ps => ps.AddChildContent<Simple1>());
@@ -28,17 +28,17 @@ public void Test010()
 	[Fact(DisplayName = "Multiple TComponent replaced in render tree with component from factory method")]
 	public void Test011()
 	{
-		var mockRepo = new MockRepository(MockBehavior.Loose);
-		ComponentFactories.Add<Simple1>(() => mockRepo.Create<Simple1>().Object);
+		ComponentFactories.Add(() => Substitute.For<Simple1>());
 
 		var cut = RenderComponent<TwoComponentWrapper>(ps => ps
 			   .Add<Simple1>(p => p.First)
 			   .Add<Simple1>(p => p.Second));
 
-		cut.FindComponents<Simple1>()
-			.ShouldAllBe(
-				x => Mock.Get(x.Instance),
-				x => Mock.Get(x.Instance));
+		foreach (var component in cut.FindComponents<Simple1>())
+		{
+			Action checkIfSubstitute = () => component.Instance.Received();
+			checkIfSubstitute.ShouldNotThrow();
+		}
 	}
 }
 
diff --git a/tests/bunit.core.tests/Rendering/TestRendererTest.net5.cs b/tests/bunit.core.tests/Rendering/TestRendererTest.net5.cs
@@ -7,7 +7,6 @@
 using Bunit.TestAssets.SampleComponents;
 using Microsoft.AspNetCore.Components;
 using Microsoft.Extensions.Logging.Abstractions;
-using Moq;
 using Xunit;
 
 namespace Bunit.Rendering;
@@ -19,17 +18,17 @@ public partial class TestRendererTest : TestContext
 						"then it used to create components")]
 	public void Test1000()
 	{
-		var activatorMock = new Mock<IComponentActivator>();
-		activatorMock.Setup(x => x.CreateInstance(typeof(Wrapper))).Returns(new Wrapper());
+		var activatorMock = Substitute.For<IComponentActivator>();
+		activatorMock.CreateInstance(typeof(Wrapper)).Returns(new Wrapper());
 		using var renderer = new TestRenderer(
 			Services.GetService<IRenderedComponentActivator>(),
 			Services,
 			NullLoggerFactory.Instance,
-			activatorMock.Object);
+			activatorMock);
 
 		renderer.RenderComponent<Wrapper>(new ComponentParameterCollection());
 
-		activatorMock.Verify(x => x.CreateInstance(typeof(Wrapper)), Times.Once());
+		activatorMock.Received(1).CreateInstance(typeof(Wrapper));
 	}
 }
 #endif
diff --git a/tests/bunit.core.tests/TestContextBaseTest.net5.cs b/tests/bunit.core.tests/TestContextBaseTest.net5.cs
@@ -11,40 +11,40 @@ public partial class TestContextBaseTest : TestContext
 	public void Test0001()
 	{
 		var mock = CreateMockComponentFactory(canCreate: _ => false, create: _ => null);
-		ComponentFactories.Add(mock.Object);
+		ComponentFactories.Add(mock);
 
 		RenderComponent<Simple1>();
 
-		mock.Verify(x => x.CanCreate(typeof(Simple1)), Times.Once);
-		mock.Verify(x => x.Create(It.IsAny<Type>()), Times.Never);
+		mock.Received(1).CanCreate(typeof(Simple1));
+		mock.DidNotReceive().Create(Arg.Any<Type>());
 	}
 
 	[Fact(DisplayName = "ComponentFactories Create() method is called when their CanCreate() method returns true")]
 	public void Test0002()
 	{
 		var mock = CreateMockComponentFactory(canCreate: _ => true, create: _ => new Simple1());
-		ComponentFactories.Add(mock.Object);
+		ComponentFactories.Add(mock);
 
 		RenderComponent<Simple1>();
 
-		mock.Verify(x => x.CanCreate(typeof(Simple1)), Times.Once);
-		mock.Verify(x => x.Create(typeof(Simple1)), Times.Once);
+		mock.Received(1).CanCreate(typeof(Simple1));
+		mock.Received(1).Create(typeof(Simple1));
 	}
 
 	[Fact(DisplayName = "ComponentFactories is used in last added order")]
 	public void Test0003()
 	{
 		var firstMock = CreateMockComponentFactory(canCreate: _ => true, create: _ => new Simple1());
 		var secondMock = CreateMockComponentFactory(canCreate: _ => true, create: _ => new Simple1());
-		ComponentFactories.Add(firstMock.Object);
-		ComponentFactories.Add(secondMock.Object);
+		ComponentFactories.Add(firstMock);
+		ComponentFactories.Add(secondMock);
 
 		RenderComponent<Simple1>();
 
-		firstMock.Verify(x => x.CanCreate(It.IsAny<Type>()), Times.Never);
-		firstMock.Verify(x => x.Create(It.IsAny<Type>()), Times.Never);
-		secondMock.Verify(x => x.CanCreate(typeof(Simple1)), Times.Once);
-		secondMock.Verify(x => x.Create(typeof(Simple1)), Times.Once);
+		firstMock.DidNotReceive().CanCreate(Arg.Any<Type>());
+		firstMock.DidNotReceive().Create(Arg.Any<Type>());
+		secondMock.Received(1).CanCreate(typeof(Simple1));
+		secondMock.Received(1).Create(typeof(Simple1));
 	}
 
 	[Fact(DisplayName = "DisposeComponents captures exceptions from DisposeAsync in Renderer.UnhandledException")]
@@ -160,11 +160,11 @@ public async ValueTask DisposeAsync()
 		}
 	}
 
-	private static Mock<IComponentFactory> CreateMockComponentFactory(Func<Type, bool> canCreate, Func<Type, IComponent> create)
+	private static IComponentFactory CreateMockComponentFactory(Func<Type, bool> canCreate, Func<Type, IComponent> create)
 	{
-		var result = new Mock<IComponentFactory>(MockBehavior.Strict);
-		result.Setup(x => x.CanCreate(It.IsAny<Type>())).Returns(canCreate);
-		result.Setup(x => x.Create(It.IsAny<Type>())).Returns(create);
+		var result = Substitute.For<IComponentFactory>();
+		result.CanCreate(Arg.Any<Type>()).Returns(call => canCreate((Type)call[0]));
+		result.Create(Arg.Any<Type>()).Returns(call => create((Type)call[0]));
 		return result;
 	}
 }
diff --git a/tests/bunit.web.testcomponents.tests/RazorTesting/RazorTestDiscovererTest.cs b/tests/bunit.web.testcomponents.tests/RazorTesting/RazorTestDiscovererTest.cs
@@ -13,8 +13,8 @@ public class RazorTestDiscovererTest
 	public RazorTestDiscovererTest()
 	{
 		options = TestFrameworkOptions.ForDiscovery();
-		messageBus = Mock.Of<IMessageSink>();
-		attribute = Mock.Of<IReflectionAttributeInfo>();
+		messageBus = Substitute.For<IMessageSink>();
+		attribute = Substitute.For<IReflectionAttributeInfo>();
 	}
 
 	[Fact(DisplayName = "Can find single razor test in test component")]
diff --git a/tests/bunit.web.testcomponents.tests/RazorTesting/RazorTestSourceInformationProviderTest.cs b/tests/bunit.web.testcomponents.tests/RazorTesting/RazorTestSourceInformationProviderTest.cs
@@ -8,7 +8,7 @@ namespace Bunit.RazorTesting;
 public sealed class RazorTestSourceInformationProviderTest : IDisposable
 {
 	private readonly TestComponentRenderer renderer = new();
-	private readonly IMessageSink messageBus = Mock.Of<IMessageSink>();
+	private readonly IMessageSink messageBus = Substitute.For<IMessageSink>();
 
 	private RazorTestBase GetTest(Type testComponent, int testIndex)
 	{
diff --git a/tests/bunit.web.tests/Asserting/CompareToDiffingExtensionsTest.cs b/tests/bunit.web.tests/Asserting/CompareToDiffingExtensionsTest.cs
@@ -22,8 +22,8 @@ public static IEnumerable<object[]> GetCompareToMethods()
 			object p1 = p1Info.ParameterType.ToMockInstance();
 			object p2 = p2Info.ParameterType.ToMockInstance();
 
-			yield return new object[] { method, p1Info.Name!, new object[] { null!, p2! } };
-			yield return new object[] { method, p2Info.Name!, new object[] { p1!, null! } };
+			yield return new object[] { method, p1Info.Name!, new[] { null!, p2! } };
+			yield return new object[] { method, p2Info.Name!, new[] { p1!, null! } };
 		}
 	}
 
diff --git a/tests/bunit.web.tests/Asserting/DiffAssertExtensionsTest.cs b/tests/bunit.web.tests/Asserting/DiffAssertExtensionsTest.cs
@@ -44,7 +44,7 @@ public void Test002(IReadOnlyList<IDiff> diffs)
 	[Fact(DisplayName = "ShouldHaveSingleChange returns the single diff in input when there is only one")]
 	public void Test003()
 	{
-		var input = new IDiff[] { Mock.Of<IDiff>() };
+		var input = new[] { Substitute.For<IDiff>() };
 
 		var output = input.ShouldHaveSingleChange();
 
@@ -58,8 +58,8 @@ public static IEnumerable<object[]> GetDiffLists()
 		{
 				new IDiff[]
 				{
-					Mock.Of<IDiff>(),
-					Mock.Of<IDiff>(),
+					Substitute.For<IDiff>(),
+					Substitute.For<IDiff>(),
 				},
 		};
 	}
diff --git a/tests/bunit.web.tests/Asserting/JSRuntimeAssertExtensionsTest.cs b/tests/bunit.web.tests/Asserting/JSRuntimeAssertExtensionsTest.cs
@@ -103,7 +103,7 @@ public void Test200()
 	public void Test201()
 	{
 		var obj = new object();
-		Should.Throw<ActualExpectedAssertException>(() => obj.ShouldBeElementReferenceTo(Mock.Of<IElement>()));
+		Should.Throw<ActualExpectedAssertException>(() => obj.ShouldBeElementReferenceTo(Substitute.For<IElement>()));
 	}
 
 	[Fact(DisplayName = "ShouldBeElementReferenceTo throws if element reference does not point to the provided element")]
diff --git a/tests/bunit.web.tests/EventDispatchExtensions/GeneralEventDispatchExtensionsTest.cs b/tests/bunit.web.tests/EventDispatchExtensions/GeneralEventDispatchExtensionsTest.cs
@@ -50,16 +50,16 @@ public void Test002()
 	[Fact(DisplayName = "TriggerEventAsync throws if element was not rendered through blazor (has a TestRendere in its context)")]
 	public void Test003()
 	{
-		var elmMock = new Mock<IElement>();
-		var docMock = new Mock<IDocument>();
-		var ctxMock = new Mock<IBrowsingContext>();
+		var elmMock = Substitute.For<IElement>();
+		var docMock = Substitute.For<IDocument>();
+		var ctxMock = Substitute.For<IBrowsingContext>();
 
-		elmMock.Setup(x => x.GetAttribute(It.IsAny<string>())).Returns("1");
-		elmMock.SetupGet(x => x.Owner).Returns(docMock.Object);
-		docMock.SetupGet(x => x.Context).Returns(ctxMock.Object);
-		ctxMock.Setup(x => x.GetService<ITestRenderer>()).Returns(() => null!);
+		elmMock.GetAttribute(Arg.Any<string>()).Returns("1");
+		elmMock.Owner.Returns(docMock);
+		docMock.Context.Returns(ctxMock);
+		ctxMock.GetService<ITestRenderer>().Returns(x => null!);
 
-		Should.Throw<InvalidOperationException>(() => elmMock.Object.TriggerEventAsync("click", EventArgs.Empty));
+		Should.Throw<InvalidOperationException>(() => elmMock.TriggerEventAsync("click", EventArgs.Empty));
 	}
 
 	[Fact(DisplayName = "When clicking on an element with an event handler, " +
diff --git a/tests/bunit.web.tests/TestDoubles/FakeSignOutSessionStateManagerTest.cs b/tests/bunit.web.tests/TestDoubles/FakeSignOutSessionStateManagerTest.cs
@@ -18,7 +18,7 @@ public void ShouldSignOut(string randomUserName)
 	[Fact]
 	public void ShouldReturnSignOutStateOnValidateSignOutState()
 	{
-		var cut = new FakeSignOutSessionStateManager(Mock.Of<IJSRuntime>());
+		var cut = new FakeSignOutSessionStateManager(Substitute.For<IJSRuntime>());
 		cut.SetSignOutState();
 
 		var wasValidate = cut.ValidateSignOutState().Result;
diff --git a/tests/bunit.web.tests/TestUtilities/MockingHelpers.cs b/tests/bunit.web.tests/TestUtilities/MockingHelpers.cs
@@ -5,10 +5,6 @@ namespace Bunit.TestUtilities;
 /// </summary>
 public static class MockingHelpers
 {
-	private static readonly MethodInfo MockOfInfo = typeof(Mock)
-		.GetMethods()
-		.First(x => string.Equals(x.Name, nameof(Mock.Of), StringComparison.Ordinal) && x.GetParameters().Length == 0);
-
 	private static readonly Type DelegateType = typeof(MulticastDelegate);
 	private static readonly Type StringType = typeof(string);
 
@@ -24,15 +20,11 @@ public static object ToMockInstance(this Type type)
 
 		if (type.IsMockable())
 		{
-			var result = MockOfInfo.MakeGenericMethod(type).Invoke(null, Array.Empty<object>());
-
-			if (result is null)
-				throw new NotSupportedException($"Cannot create an mock of {type.FullName}.");
-
-			return result;
+			var result = Substitute.For(new[] { type }, Array.Empty<object>());
+			return result ?? throw new NotSupportedException($"Cannot create an mock of {type.FullName}.");
 		}
 
-		if (type.Equals(StringType))
+		if (type == StringType)
 		{
 			return string.Empty;
 		}
@@ -48,16 +40,11 @@ public static bool IsMockable(this Type type)
 		if (type is null)
 			throw new ArgumentNullException(nameof(type));
 
-		if (type.IsSealed)
-			return type.IsDelegateType();
-		return true;
+		return !type.IsSealed || type.IsDelegateType();
 	}
 
 	/// <summary>
 	/// Gets whether a type is a delegate type.
 	/// </summary>
-	public static bool IsDelegateType(this Type type)
-	{
-		return Equals(type, DelegateType);
-	}
+	public static bool IsDelegateType(this Type type) => type == DelegateType;
 }

Original file line number	Diff line number	Diff line change
`@@ -11,40 +11,40 @@ public partial class TestContextBaseTest : TestContext`
`11`	`11`	`public void Test0001()`
`12`	`12`	`{`
`13`	`13`	`var mock = CreateMockComponentFactory(canCreate: _ => false, create: _ => null);`
`14`		`- ComponentFactories.Add(mock.Object);`
	`14`	`+ ComponentFactories.Add(mock);`
`15`	`15`
`16`	`16`	`RenderComponent<Simple1>();`
`17`	`17`
`18`		`- mock.Verify(x => x.CanCreate(typeof(Simple1)), Times.Once);`
`19`		`- mock.Verify(x => x.Create(It.IsAny<Type>()), Times.Never);`
	`18`	`+ mock.Received(1).CanCreate(typeof(Simple1));`
	`19`	`+ mock.DidNotReceive().Create(Arg.Any<Type>());`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`[Fact(DisplayName = "ComponentFactories Create() method is called when their CanCreate() method returns true")]`
`23`	`23`	`public void Test0002()`
`24`	`24`	`{`
`25`	`25`	`var mock = CreateMockComponentFactory(canCreate: _ => true, create: _ => new Simple1());`
`26`		`- ComponentFactories.Add(mock.Object);`
	`26`	`+ ComponentFactories.Add(mock);`
`27`	`27`
`28`	`28`	`RenderComponent<Simple1>();`
`29`	`29`
`30`		`- mock.Verify(x => x.CanCreate(typeof(Simple1)), Times.Once);`
`31`		`- mock.Verify(x => x.Create(typeof(Simple1)), Times.Once);`
	`30`	`+ mock.Received(1).CanCreate(typeof(Simple1));`
	`31`	`+ mock.Received(1).Create(typeof(Simple1));`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`[Fact(DisplayName = "ComponentFactories is used in last added order")]`
`35`	`35`	`public void Test0003()`
`36`	`36`	`{`
`37`	`37`	`var firstMock = CreateMockComponentFactory(canCreate: _ => true, create: _ => new Simple1());`
`38`	`38`	`var secondMock = CreateMockComponentFactory(canCreate: _ => true, create: _ => new Simple1());`
`39`		`- ComponentFactories.Add(firstMock.Object);`
`40`		`- ComponentFactories.Add(secondMock.Object);`
	`39`	`+ ComponentFactories.Add(firstMock);`
	`40`	`+ ComponentFactories.Add(secondMock);`
`41`	`41`
`42`	`42`	`RenderComponent<Simple1>();`
`43`	`43`
`44`		`- firstMock.Verify(x => x.CanCreate(It.IsAny<Type>()), Times.Never);`
`45`		`- firstMock.Verify(x => x.Create(It.IsAny<Type>()), Times.Never);`
`46`		`- secondMock.Verify(x => x.CanCreate(typeof(Simple1)), Times.Once);`
`47`		`- secondMock.Verify(x => x.Create(typeof(Simple1)), Times.Once);`
	`44`	`+ firstMock.DidNotReceive().CanCreate(Arg.Any<Type>());`
	`45`	`+ firstMock.DidNotReceive().Create(Arg.Any<Type>());`
	`46`	`+ secondMock.Received(1).CanCreate(typeof(Simple1));`
	`47`	`+ secondMock.Received(1).Create(typeof(Simple1));`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`[Fact(DisplayName = "DisposeComponents captures exceptions from DisposeAsync in Renderer.UnhandledException")]`
`@@ -160,11 +160,11 @@ public async ValueTask DisposeAsync()`
`160`	`160`	`}`
`161`	`161`	`}`
`162`	`162`
`163`		`- private static Mock<IComponentFactory> CreateMockComponentFactory(Func<Type, bool> canCreate, Func<Type, IComponent> create)`
	`163`	`+ private static IComponentFactory CreateMockComponentFactory(Func<Type, bool> canCreate, Func<Type, IComponent> create)`
`164`	`164`	`{`
`165`		`- var result = new Mock<IComponentFactory>(MockBehavior.Strict);`
`166`		`- result.Setup(x => x.CanCreate(It.IsAny<Type>())).Returns(canCreate);`
`167`		`- result.Setup(x => x.Create(It.IsAny<Type>())).Returns(create);`
	`165`	`+ var result = Substitute.For<IComponentFactory>();`
	`166`	`+ result.CanCreate(Arg.Any<Type>()).Returns(call => canCreate((Type)call[0]));`
	`167`	`+ result.Create(Arg.Any<Type>()).Returns(call => create((Type)call[0]));`
`168`	`168`	`return result;`
`169`	`169`	`}`
`170`	`170`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,8 @@ public class RazorTestDiscovererTest`
`13`	`13`	`public RazorTestDiscovererTest()`
`14`	`14`	`{`
`15`	`15`	`options = TestFrameworkOptions.ForDiscovery();`
`16`		`- messageBus = Mock.Of<IMessageSink>();`
`17`		`- attribute = Mock.Of<IReflectionAttributeInfo>();`
	`16`	`+ messageBus = Substitute.For<IMessageSink>();`
	`17`	`+ attribute = Substitute.For<IReflectionAttributeInfo>();`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`[Fact(DisplayName = "Can find single razor test in test component")]`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ namespace Bunit.RazorTesting;`
`8`	`8`	`public sealed class RazorTestSourceInformationProviderTest : IDisposable`
`9`	`9`	`{`
`10`	`10`	`private readonly TestComponentRenderer renderer = new();`
`11`		`- private readonly IMessageSink messageBus = Mock.Of<IMessageSink>();`
	`11`	`+ private readonly IMessageSink messageBus = Substitute.For<IMessageSink>();`
`12`	`12`
`13`	`13`	`private RazorTestBase GetTest(Type testComponent, int testIndex)`
`14`	`14`	`{`
Original file line number	Diff line number	Diff line change
`@@ -22,8 +22,8 @@ public static IEnumerable<object[]> GetCompareToMethods()`
`22`	`22`	`object p1 = p1Info.ParameterType.ToMockInstance();`
`23`	`23`	`object p2 = p2Info.ParameterType.ToMockInstance();`
`24`	`24`
`25`		`- yield return new object[] { method, p1Info.Name!, new object[] { null!, p2! } };`
`26`		`- yield return new object[] { method, p2Info.Name!, new object[] { p1!, null! } };`
	`25`	`+ yield return new object[] { method, p1Info.Name!, new[] { null!, p2! } };`
	`26`	`+ yield return new object[] { method, p2Info.Name!, new[] { p1!, null! } };`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ public void Test002(IReadOnlyList<IDiff> diffs)`
`44`	`44`	`[Fact(DisplayName = "ShouldHaveSingleChange returns the single diff in input when there is only one")]`
`45`	`45`	`public void Test003()`
`46`	`46`	`{`
`47`		`- var input = new IDiff[] { Mock.Of<IDiff>() };`
	`47`	`+ var input = new[] { Substitute.For<IDiff>() };`
`48`	`48`
`49`	`49`	`var output = input.ShouldHaveSingleChange();`
`50`	`50`
`@@ -58,8 +58,8 @@ public static IEnumerable<object[]> GetDiffLists()`
`58`	`58`	`{`
`59`	`59`	`new IDiff[]`
`60`	`60`	`{`
`61`		`- Mock.Of<IDiff>(),`
`62`		`- Mock.Of<IDiff>(),`
	`61`	`+ Substitute.For<IDiff>(),`
	`62`	`+ Substitute.For<IDiff>(),`
`63`	`63`	`},`
`64`	`64`	`};`
`65`	`65`	`}`