refactor: use aweXpect in testinghelper tests

tests/TestableIO.System.IO.Abstractions.TestingHelpers.Tests/MockDirectoryArgumentPathTests.cs

@@ -29,17 +29,17 @@ private static IEnumerable<Action<IDirectory>> GetFileSystemActionsForArgumentNu
         }
 
         [TestCaseSource(nameof(GetFileSystemActionsForArgumentNullException))]
-        public void Operations_ShouldThrowArgumentNullExceptionIfPathIsNull(Action<IDirectory> action)
+        public async Task Operations_ShouldThrowArgumentNullExceptionIfPathIsNull(Action<IDirectory> action)
         {
             // Arrange
             var fileSystem = new MockFileSystem();
 
             // Act
-            TestDelegate wrapped = () => action(fileSystem.Directory);
+            Action wrapped = () => action(fileSystem.Directory);
 
             // Assert
-            var exception = Assert.Throws<ArgumentNullException>(wrapped);
-            Assert.That(exception.ParamName, Is.EqualTo("path"));
+            var exception = await That(wrapped).Throws<ArgumentNullException>();
+            await That(exception.ParamName).IsEqualTo("path");
         }
     }
 }

tests/TestableIO.System.IO.Abstractions.TestingHelpers.Tests/MockDirectoryGetAccessControlTests.cs

@@ -13,35 +13,35 @@ public class MockDirectoryGetAccessControlTests
     {
         [TestCase(" ")]
         [TestCase("   ")]
-        public void MockDirectory_GetAccessControl_ShouldThrowArgumentExceptionIfPathContainsOnlyWhitespaces(string path)
+        public async Task MockDirectory_GetAccessControl_ShouldThrowArgumentExceptionIfPathContainsOnlyWhitespaces(string path)
         {
             // Arrange
             var fileSystem = new MockFileSystem();
 
             // Act
-            TestDelegate action = () => fileSystem.Directory.GetAccessControl(path);
+            Action action = () => fileSystem.Directory.GetAccessControl(path);
 
             // Assert
-            var exception = Assert.Throws<ArgumentException>(action);
-            Assert.That(exception.ParamName, Is.EqualTo("path"));
+            var exception = await That(action).Throws<ArgumentException>();
+            await That(exception.ParamName).IsEqualTo("path");
         }
 
         [Test]
-        public void MockDirectory_GetAccessControl_ShouldThrowDirectoryNotFoundExceptionIfDirectoryDoesNotExistInMockData()
+        public async Task MockDirectory_GetAccessControl_ShouldThrowDirectoryNotFoundExceptionIfDirectoryDoesNotExistInMockData()
         {
             // Arrange
             var fileSystem = new MockFileSystem();
             var expectedDirectoryName = XFS.Path(@"c:\a");
 
             // Act
-            TestDelegate action = () => fileSystem.Directory.GetAccessControl(expectedDirectoryName);
+            Action action = () => fileSystem.Directory.GetAccessControl(expectedDirectoryName);
 
             // Assert
-            Assert.Throws<DirectoryNotFoundException>(action);
+            await That(action).Throws<DirectoryNotFoundException>();
         }
 
         [Test]
-        public void MockDirectory_GetAccessControl_ShouldReturnAccessControlOfDirectoryData()
+        public async Task MockDirectory_GetAccessControl_ShouldReturnAccessControlOfDirectoryData()
         {
             // Arrange
             var expectedDirectorySecurity = new DirectorySecurity();
@@ -62,7 +62,7 @@ public void MockDirectory_GetAccessControl_ShouldReturnAccessControlOfDirectoryD
             var directorySecurity = fileSystem.Directory.GetAccessControl(filePath);
 
             // Assert
-            Assert.That(directorySecurity, Is.EqualTo(expectedDirectorySecurity));
+            await That(directorySecurity).IsEqualTo(expectedDirectorySecurity);
         }
     }
 }

tests/TestableIO.System.IO.Abstractions.TestingHelpers.Tests/MockDirectoryInfoAccessControlTests.cs

@@ -12,7 +12,7 @@ namespace System.IO.Abstractions.TestingHelpers.Tests
     public class MockDirectoryInfoAccessControlTests
     {
         [Test]
-        public void MockDirectoryInfo_GetAccessControl_ShouldReturnAccessControlOfDirectoryData()
+        public async Task MockDirectoryInfo_GetAccessControl_ShouldReturnAccessControlOfDirectoryData()
         {
             // Arrange
             var expectedDirectorySecurity = new DirectorySecurity();
@@ -35,11 +35,11 @@ public void MockDirectoryInfo_GetAccessControl_ShouldReturnAccessControlOfDirect
             var directorySecurity = directorInfo.GetAccessControl();
 
             // Assert
-            Assert.That(directorySecurity, Is.EqualTo(expectedDirectorySecurity));
+            await That(directorySecurity).IsEqualTo(expectedDirectorySecurity);
         }
 
         [Test]
-        public void MockDirectoryInfo_SetAccessControl_ShouldSetAccessControlOfDirectoryData()
+        public async Task MockDirectoryInfo_SetAccessControl_ShouldSetAccessControlOfDirectoryData()
         {
             // Arrange
             var filePath = XFS.Path(@"c:\a\");
@@ -59,7 +59,7 @@ public void MockDirectoryInfo_SetAccessControl_ShouldSetAccessControlOfDirectory
 
             // Assert
             var accessControl = directorInfo.GetAccessControl();
-            Assert.That(accessControl, Is.EqualTo(expectedAccessControl));
+            await That(accessControl).IsEqualTo(expectedAccessControl);
         }
     }
 }

tests/TestableIO.System.IO.Abstractions.TestingHelpers.Tests/MockDirectoryInfoFactoryTests.cs

@@ -6,24 +6,24 @@ namespace System.IO.Abstractions.TestingHelpers.Tests
     public class MockDirectoryInfoFactoryTests
     {
         [Test]
-        public void MockDirectoryInfoFactory_Wrap_WithNull_ShouldReturnNull()
+        public async Task MockDirectoryInfoFactory_Wrap_WithNull_ShouldReturnNull()
         {
             var fileSystem = new MockFileSystem();
 
             var result = fileSystem.DirectoryInfo.Wrap(null);
 
-            Assert.That(result, Is.Null);
+            await That(result).IsNull();
         }
 
         [Test]
-        public void MockDirectoryInfoFactory_Wrap_ShouldKeepNameAndFullName()
+        public async Task MockDirectoryInfoFactory_Wrap_ShouldKeepNameAndFullName()
         {
             var fs = new MockFileSystem();
             var directoryInfo = new DirectoryInfo(@"C:\subfolder\file");
             var wrappedDirectoryInfo = fs.DirectoryInfo.Wrap(directoryInfo);
 
-            Assert.That(wrappedDirectoryInfo.FullName, Is.EqualTo(directoryInfo.FullName));
-            Assert.That(wrappedDirectoryInfo.Name, Is.EqualTo(directoryInfo.Name));
+            await That(wrappedDirectoryInfo.FullName).IsEqualTo(directoryInfo.FullName);
+            await That(wrappedDirectoryInfo.Name).IsEqualTo(directoryInfo.Name);
         }
     }
 }

tests/TestableIO.System.IO.Abstractions.TestingHelpers.Tests/MockDirectoryInfoSymlinkTests.cs

@@ -15,19 +15,19 @@ public class MockDirectoryInfoSymlinkTests
 #if FEATURE_CREATE_SYMBOLIC_LINK
 
         [Test]
-        public void MockDirectoryInfo_ResolveLinkTarget_ShouldReturnPathOfTargetLink()
+        public async Task MockDirectoryInfo_ResolveLinkTarget_ShouldReturnPathOfTargetLink()
         {
             var fileSystem = new MockFileSystem();
             fileSystem.Directory.CreateDirectory("bar");
             fileSystem.Directory.CreateSymbolicLink("foo", "bar");
 
             var result = fileSystem.DirectoryInfo.New("foo").ResolveLinkTarget(false);
 
-            Assert.That(result.Name, Is.EqualTo("bar"));
+            await That(result.Name).IsEqualTo("bar");
         }
 
         [Test]
-        public void MockDirectoryInfo_ResolveLinkTarget_WithFinalTarget_ShouldReturnPathOfTargetLink()
+        public async Task MockDirectoryInfo_ResolveLinkTarget_WithFinalTarget_ShouldReturnPathOfTargetLink()
         {
             var fileSystem = new MockFileSystem();
             fileSystem.Directory.CreateDirectory("bar");
@@ -36,11 +36,11 @@ public void MockDirectoryInfo_ResolveLinkTarget_WithFinalTarget_ShouldReturnPath
 
             var result = fileSystem.DirectoryInfo.New("foo1").ResolveLinkTarget(true);
 
-            Assert.That(result.Name, Is.EqualTo("bar"));
+            await That(result.Name).IsEqualTo("bar");
         }
 
         [Test]
-        public void MockDirectoryInfo_ResolveLinkTarget_WithoutFinalTarget_ShouldReturnFirstLink()
+        public async Task MockDirectoryInfo_ResolveLinkTarget_WithoutFinalTarget_ShouldReturnFirstLink()
         {
             var fileSystem = new MockFileSystem();
             fileSystem.Directory.CreateDirectory("bar");
@@ -49,20 +49,20 @@ public void MockDirectoryInfo_ResolveLinkTarget_WithoutFinalTarget_ShouldReturnF
 
             var result = fileSystem.DirectoryInfo.New("foo1").ResolveLinkTarget(false);
 
-            Assert.That(result.Name, Is.EqualTo("foo"));
+            await That(result.Name).IsEqualTo("foo");
         }
 
         [Test]
-        public void MockDirectoryInfo_ResolveLinkTarget_WithoutTargetLink_ShouldThrowIOException()
+        public async Task MockDirectoryInfo_ResolveLinkTarget_WithoutTargetLink_ShouldThrowIOException()
         {
             var fileSystem = new MockFileSystem();
             fileSystem.Directory.CreateDirectory("bar");
             fileSystem.Directory.CreateSymbolicLink("foo", "bar");
 
-            Assert.Throws<IOException>(() =>
+            await That(() =>
             {
                 fileSystem.DirectoryInfo.New("bar").ResolveLinkTarget(false);
-            });
+            }).Throws<IOException>();
         }
 #endif
     }