refactor: replace Moq with Mockolate

Author: vbreuss

Directory.Packages.props

@@ -22,7 +22,7 @@
     <PackageVersion Include="coverlet.collector" Version="6.0.4" />
     <PackageVersion Include="GitHubActionsTestLogger" Version="3.0.1" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.14.0" />
-    <PackageVersion Include="Moq" Version="4.20.72" />
+    <PackageVersion Include="Mockolate" Version="1.0.0" />
     <PackageVersion Include="NUnit" Version="4.4.0" />
     <PackageVersion Include="NUnit.Analyzers" Version="4.11.2" />
     <PackageVersion Include="NUnit3TestAdapter" Version="6.1.0" />

README.md

@@ -101,27 +101,27 @@ void MyFancyMethod()
 
 ### Mock support
 
-Since version 4.0 the top-level APIs expose interfaces instead of abstract base classes (these still exist, though), allowing you to completely mock the file system. Here's a small example, using [Moq](https://github.com/moq/moq4):
+Since version 4.0 the top-level APIs expose interfaces instead of abstract base classes (these still exist, though), allowing you to completely mock the file system. Here's a small example, using [Mockolate](https://github.com/aweXpect/Mockolate):
 
 ```csharp
 [Test]
 public void Test1()
 {
-    var watcher = Mock.Of<IFileSystemWatcher>();
-    var file = Mock.Of<IFile>();
+    var watcher = Mock.Create<IFileSystemWatcher>();
+    var file = Mock.Create<IFile>();
 
-    Mock.Get(file).Setup(f => f.Exists(It.IsAny<string>())).Returns(true);
-    Mock.Get(file).Setup(f => f.ReadAllText(It.IsAny<string>())).Throws<OutOfMemoryException>();
+    file.SetupMock.Method.Exists(It.IsAny<string>()).Returns(true);
+    file.SetupMock.Method.ReadAllText(It.IsAny<string>()).Throws<OutOfMemoryException>();
 
     var unitUnderTest = new SomeClassUsingFileSystemWatcher(watcher, file);
 
     Assert.Throws<OutOfMemoryException>(() => {
-        Mock.Get(watcher).Raise(w => w.Created += null, new System.IO.FileSystemEventArgs(System.IO.WatcherChangeTypes.Created, @"C:\Some\Directory", "Some.File"));
+        watcher.RaiseOnMock.Created(null, new System.IO.FileSystemEventArgs(System.IO.WatcherChangeTypes.Created, @"C:\Some\Directory", "Some.File"));
     });
 
-    Mock.Get(file).Verify(f => f.Exists(It.IsAny<string>()), Times.Once);
+    file.VerifyMock.Invoked.Exists(It.IsAny<string>()).Once();
 
-    Assert.True(unitUnderTest.FileWasCreated);
+    Assert.That(unitUnderTest.FileWasCreated, Is.True);
 }
 
 public class SomeClassUsingFileSystemWatcher

tests/Directory.Build.props

@@ -18,7 +18,7 @@
         </PackageReference>
         <PackageReference Include="GitHubActionsTestLogger" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" />
-        <PackageReference Include="Moq" />
+        <PackageReference Include="Mockolate" />
         <PackageReference Include="NUnit" />
         <PackageReference Include="NUnit.Analyzers">
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

tests/TestableIO.System.IO.Abstractions.Wrappers.Tests/FileSystemTests.cs

@@ -1,4 +1,7 @@
-namespace System.IO.Abstractions.Tests;
+#if !NET6_0
+using Mockolate;
+
+namespace System.IO.Abstractions.Tests;
 
 [TestFixture]
 public class FileSystemTests
@@ -24,80 +27,89 @@ await That(memoryStream).HasLength().GreaterThan(0)
     [Test]
     public async Task Mock_File_Succeeds()
     {
-        var fileSystemMock = new Moq.Mock<IFileSystem>();
+        var fileSystemMock = Mock.Create<IFileSystem>(fs =>
+            fs.Property.File.InitializeWith(Mock.Create<IFile>()));
 
         await That(() =>
-            fileSystemMock.Setup(x => x.File.ToString()).Returns("")
+            fileSystemMock.File.SetupMock.Method.ReadAllText(It.IsAny<string>()).Returns("")
         ).DoesNotThrow();
     }
 
     [Test]
     public async Task Mock_Directory_Succeeds()
     {
-        var fileSystemMock = new Moq.Mock<IFileSystem>();
+        var fileSystemMock = Mock.Create<IFileSystem>(fs =>
+            fs.Property.Directory.InitializeWith(Mock.Create<IDirectory>()));
 
         await That(() =>
-            fileSystemMock.Setup(x => x.Directory.ToString()).Returns("")
+            fileSystemMock.Directory.SetupMock.Method.CreateDirectory(It.IsAny<string>())
         ).DoesNotThrow();
     }
 
     [Test]
     public async Task Mock_FileInfo_Succeeds()
     {
-        var fileSystemMock = new Moq.Mock<IFileSystem>();
+        var fileSystemMock = Mock.Create<IFileSystem>(fs =>
+            fs.Property.FileInfo.InitializeWith(Mock.Create<IFileInfoFactory>()));
 
         await That(() =>
-            fileSystemMock.Setup(x => x.FileInfo.ToString()).Returns("")
+            fileSystemMock.FileInfo.SetupMock.Method.New(It.IsAny<string>())
         ).DoesNotThrow();
     }
 
     [Test]
     public async Task Mock_FileStream_Succeeds()
     {
-        var fileSystemMock = new Moq.Mock<IFileSystem>();
+        var fileSystemMock = Mock.Create<IFileSystem>(fs =>
+            fs.Property.FileStream.InitializeWith(Mock.Create<IFileStreamFactory>()));
 
         await That(() =>
-            fileSystemMock.Setup(x => x.FileStream.ToString()).Returns("")
+            fileSystemMock.FileStream.SetupMock.Method.New(It.IsAny<string>(), It.IsAny<FileMode>())
         ).DoesNotThrow();
     }
 
     [Test]
     public async Task Mock_Path_Succeeds()
     {
-        var fileSystemMock = new Moq.Mock<IFileSystem>();
+        var fileSystemMock = Mock.Create<IFileSystem>(fs =>
+            fs.Property.Path.InitializeWith(Mock.Create<IPath>()));
 
         await That(() =>
-            fileSystemMock.Setup(x => x.Path.ToString()).Returns("")
+            fileSystemMock.Path.SetupMock.Method.Combine(It.IsAny<string>(), It.IsAny<string>())
         ).DoesNotThrow();
     }
 
     [Test]
     public async Task Mock_DirectoryInfo_Succeeds()
     {
-        var fileSystemMock = new Moq.Mock<IFileSystem>();
+        var fileSystemMock = Mock.Create<IFileSystem>(fs =>
+            fs.Property.DirectoryInfo.InitializeWith(Mock.Create<IDirectoryInfoFactory>()));
 
         await That(() =>
-            fileSystemMock.Setup(x => x.DirectoryInfo.ToString()).Returns("")
+            fileSystemMock.DirectoryInfo.SetupMock.Method.New(It.IsAny<string>())
         ).DoesNotThrow();
     }
 
     [Test]
     public async Task Mock_DriveInfo_Succeeds()
     {
-        var fileSystemMock = new Moq.Mock<IFileSystem>();
+        var fileSystemMock = Mock.Create<IFileSystem>(fs =>
+            fs.Property.DriveInfo.InitializeWith(Mock.Create<IDriveInfoFactory>()));
 
         await That(() =>
-            fileSystemMock.Setup(x => x.DirectoryInfo.ToString()).Returns("")
+            fileSystemMock.DriveInfo.SetupMock.Method.New(It.IsAny<string>())
         ).DoesNotThrow();
     }
 
     [Test]
     public async Task Mock_FileSystemWatcher_Succeeds()
     {
-        var fileSystemMock = new Moq.Mock<IFileSystem>();
+        var fileSystemMock = Mock.Create<IFileSystem>(fs =>
+            fs.Property.FileSystemWatcher.InitializeWith(Mock.Create<IFileSystemWatcherFactory>()));
 
         await That(() =>
-            fileSystemMock.Setup(x => x.FileSystemWatcher.ToString()).Returns("")
+            fileSystemMock.FileSystemWatcher.SetupMock.Method.New(It.IsAny<string>())
         ).DoesNotThrow();
     }
-}
+}
+#endif