fix: compile errors in Examples.sln (#822)

This PR migrates test projects from FluentAssertions and AutoFixture to aweXpect for assertion testing across multiple example projects. The primary goal is to fix compile errors in Examples.sln by updating testing dependencies and assertion syntax.

### Key changes:
- Replaced FluentAssertions and AutoFixture.Xunit2 with aweXpect assertion library
- Updated package references in Directory.Build.props to include aweXpect packages
- Converted synchronous test methods to async Task methods to support aweXpect's async assertions

Author: vbreuss

Examples/.idea/.idea.Examples/.idea/.gitignore

@@ -1,39 +1,44 @@
-using AutoFixture.Xunit2;
-using FluentAssertions;
-using System;
+using aweXpect;
 using System.IO;
+using System.Threading.Tasks;
 using Testably.Abstractions.Testing;
 using Xunit;
 
 namespace Testably.Abstractions.Examples.AccessControlLists.Tests;
 
 public class AccessControlListTests
 {
+	#region Test Setup
+
+	public MockFileSystem FileSystem { get; }
+
 	public AccessControlListTests()
 	{
 		FileSystem = new MockFileSystem();
 	}
 
-	public MockFileSystem FileSystem { get; }
+	#endregion
 
 	[Theory]
-	[AutoData]
-	public void ReadAllText_DeniedPath_ShouldThrowIOException(string grantedPath, string deniedPath)
+	[InlineData("granted", "denied")]
+	public async Task ReadAllText_DeniedPath_ShouldThrowIOException(string grantedPath,
+		string deniedPath)
 	{
 		FileSystem.File.WriteAllText(grantedPath, "foo");
 		FileSystem.File.WriteAllText(deniedPath, "bar");
-		FileSystem.WithAccessControlStrategy(new CustomAccessControlStrategy(
-			path => path.Contains(grantedPath)));
+		FileSystem.WithAccessControlStrategy(
+			new CustomAccessControlStrategy(path => path.Contains(grantedPath)));
 
 		string result = FileSystem.File.ReadAllText(grantedPath);
-		result.Should().Be("foo");
+		await Expect.That(result).IsEqualTo("foo");
 
-		Exception? exception = Record.Exception(() =>
+		void Act()
 		{
 			FileSystem.File.ReadAllText(deniedPath);
-		});
-		exception.Should().BeOfType<IOException>()
-			.Which.Message.Should()
-			.Be($"Access to the path '{FileSystem.Path.GetFullPath(deniedPath)}' is denied.");
+		}
+
+		await Expect.That(Act).Throws<IOException>()
+			.WithMessage(
+				$"Access to the path '{FileSystem.Path.GetFullPath(deniedPath)}' is denied.");
 	}
 }

Examples/.idea/.idea.Examples/.idea/indexLayout.xml

@@ -1,14 +1,15 @@
-using FluentAssertions;
+using aweXpect;
 using Microsoft.Extensions.DependencyInjection;
 using System.IO.Abstractions;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace Testably.Abstractions.Examples.Configuration.DependencyInjection.Tests;
 
 public class DependencyInjectionTests
 {
 	[Fact]
-	public void
+	public async Task
 		DependencyInjection_Microsoft_ShouldAllowRegistrationAndCreationOfInstances()
 	{
 		ServiceProvider services = new ServiceCollection()
@@ -17,8 +18,8 @@ public void
 			.AddSingleton<ITimeSystem, RealTimeSystem>()
 			.BuildServiceProvider();
 
-		services.GetService<IFileSystem>().Should().BeOfType<RealFileSystem>();
-		services.GetService<IRandomSystem>().Should().BeOfType<RealRandomSystem>();
-		services.GetService<ITimeSystem>().Should().BeOfType<RealTimeSystem>();
+		await Expect.That(services.GetService<IFileSystem>()).Is<RealFileSystem>();
+		await Expect.That(services.GetService<IRandomSystem>()).Is<RealRandomSystem>();
+		await Expect.That(services.GetService<ITimeSystem>()).Is<RealTimeSystem>();
 	}
 }

Examples/AccessControlLists/AccessControlLists.Tests/AccessControlListTests.cs

@@ -1,10 +1,8 @@
-using AutoFixture.Xunit2;
-using FluentAssertions;
-using System;
+using aweXpect;
 using System.IO;
 using System.IO.Abstractions;
-using System.Linq;
 using System.Runtime.InteropServices;
+using System.Threading.Tasks;
 using Testably.Abstractions.RandomSystem;
 using Testably.Abstractions.Testing;
 using Xunit;
@@ -18,18 +16,16 @@ public class InitializationTests
 	///     - a randomly named directory
 	/// </summary>
 	[Theory]
-	[AutoData]
-	public void InitializeFileSystemInSpecifiedCurrentDirectory(string currentDirectory)
+	[InlineData("foo")]
+	public async Task InitializeFileSystemInSpecifiedCurrentDirectory(string currentDirectory)
 	{
 		MockFileSystem fileSystem = new();
 		string expectedDirectory = fileSystem.Path.GetFullPath(currentDirectory);
 
 		fileSystem.InitializeIn(currentDirectory)
 			.WithASubdirectory();
 
-		fileSystem.Directory.GetCurrentDirectory()
-			.Should()
-			.Be(expectedDirectory);
+		await Expect.That(fileSystem.Directory.GetCurrentDirectory()).IsEqualTo(expectedDirectory);
 	}
 
 	/// <summary>
@@ -39,7 +35,7 @@ public void InitializeFileSystemInSpecifiedCurrentDirectory(string currentDirect
 	///     - a file named "bar.txt"
 	/// </summary>
 	[Fact]
-	public void InitializeFileSystemInTheRootDirectory()
+	public async Task InitializeFileSystemInTheRootDirectory()
 	{
 		MockFileSystem fileSystem = new();
 		fileSystem.InitializeIn("base-directory")
@@ -49,9 +45,9 @@ public void InitializeFileSystemInTheRootDirectory()
 				.WithAFile())
 			.WithFile("bar.txt");
 
-		fileSystem.File.Exists("bar.txt").Should().BeTrue();
-		fileSystem.Directory.Exists("foo").Should().BeTrue();
-		fileSystem.Directory.GetDirectories(".").Length.Should().Be(2);
+		await Expect.That(fileSystem.File.Exists("bar.txt")).IsTrue();
+		await Expect.That(fileSystem.Directory.Exists("foo")).IsTrue();
+		await Expect.That(fileSystem.Directory.GetDirectories(".")).HasCount(2);
 	}
 
 	/// <summary>
@@ -60,20 +56,20 @@ public void InitializeFileSystemInTheRootDirectory()
 	///     UNC servers (or additional drives under windows) can be added if required.
 	/// </summary>
 	[Fact]
-	public void InitializeFileSystemWithUncDrive()
+	public async Task InitializeFileSystemWithUncDrive()
 	{
 		MockFileSystem fileSystem = new();
-		var initialDriveCount = fileSystem.DriveInfo.GetDrives().Length;
+		int initialDriveCount = fileSystem.DriveInfo.GetDrives().Length;
 
 		fileSystem.WithUncDrive(@"//unc-server");
 
-		fileSystem.DriveInfo.GetDrives().Should().HaveCount(initialDriveCount);
+		await Expect.That(fileSystem.DriveInfo.GetDrives()).HasCount(initialDriveCount);
 		IDriveInfo drive = fileSystem.DriveInfo.New(@"//unc-server");
-		drive.IsReady.Should().BeTrue();
+		await Expect.That(drive.IsReady).IsTrue();
 
 		if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
 		{
-			fileSystem.DriveInfo.GetDrives().Should().HaveCount(initialDriveCount);
+			await Expect.That(fileSystem.DriveInfo.GetDrives()).HasCount(initialDriveCount);
 		}
 	}
 
@@ -84,7 +80,7 @@ public void InitializeFileSystemWithUncDrive()
 	///     <see cref="IOException" />, when the limit is breached.
 	/// </summary>
 	[Fact]
-	public void LimitAvailableSpaceOnDrives()
+	public async Task LimitAvailableSpaceOnDrives()
 	{
 		MockFileSystem fileSystem = new();
 		IRandom random = fileSystem.RandomSystem.Random.Shared;
@@ -96,16 +92,16 @@ public void LimitAvailableSpaceOnDrives()
 		// Limit the main drive to 200 bytes
 		fileSystem.WithDrive(drive => drive.SetTotalSize(200));
 		IDriveInfo mainDrive = fileSystem.GetDefaultDrive();
-		mainDrive.AvailableFreeSpace.Should().Be(200);
+		await Expect.That(mainDrive.AvailableFreeSpace).IsEqualTo(200);
 
 		fileSystem.File.WriteAllBytes("foo", firstFileContent);
-		mainDrive.AvailableFreeSpace.Should().Be(1);
+		await Expect.That(mainDrive.AvailableFreeSpace).IsEqualTo(1);
 
-		Exception? exception = Record.Exception(() =>
+		void Act()
 		{
 			fileSystem.File.WriteAllBytes("bar", secondFileContent);
-		});
+		}
 
-		exception.Should().BeOfType<IOException>();
+		await Expect.That(Act).Throws<IOException>();
 	}
 }

Examples/Configuration/DependencyInjection.Tests/DependencyInjectionTests.cs

@@ -1,6 +1,6 @@
-using AutoFixture.Xunit2;
-using FluentAssertions;
+using aweXpect;
 using System;
+using System.Threading.Tasks;
 using Testably.Abstractions.Testing;
 using Xunit;
 
@@ -11,22 +11,22 @@ public class InterceptionTests
 	/// <summary>
 	///     Intercepting allows callbacks to be invoked before the change in the file system is performed.
 	/// </summary>
-	[Theory]
-	[AutoData]
-	public void Intercept(Exception customException)
+	[Fact]
+	public async Task Intercept()
 	{
+		Exception customException = new ApplicationException("bar");
 		MockFileSystem fileSystem = new();
 		fileSystem.Intercept.Creating(FileSystemTypes.File,
 			_ => throw customException);
 
 		fileSystem.Directory.CreateDirectory("foo");
 
-		Exception exception = Record.Exception(() =>
+		Exception? exception = Record.Exception(() =>
 		{
 			fileSystem.File.Create("foo/bar.txt");
 		});
 
-		exception.Should().Be(customException);
-		fileSystem.File.Exists("foo/bar.txt").Should().BeFalse();
+		await Expect.That(exception).IsSameAs(customException);
+		await Expect.That(fileSystem.File.Exists("foo/bar.txt")).IsFalse();
 	}
 }

Examples/Configuration/FileSystemConfiguration.Tests/InitializationTests.cs

@@ -1,5 +1,6 @@
-using FluentAssertions;
+using aweXpect;
 using System.Threading;
+using System.Threading.Tasks;
 using Testably.Abstractions.Testing;
 using Xunit;
 
@@ -11,7 +12,7 @@ public class NotificationTests
 	///     Notifications allow reacting to an event after it occurred.
 	/// </summary>
 	[Fact]
-	public void Notify_ManualWait()
+	public async Task Notify_ManualWait()
 	{
 		ManualResetEventSlim ms = new();
 		bool isNotified = false;
@@ -26,16 +27,16 @@ public void Notify_ManualWait()
 		fileSystem.Directory.CreateDirectory("foo");
 		fileSystem.File.Create("foo/bar.txt");
 
-		ms.Wait();
-		fileSystem.File.Exists("foo/bar.txt").Should().BeTrue();
-		isNotified.Should().BeTrue();
+		ms.Wait(TestContext.Current.CancellationToken);
+		await Expect.That(fileSystem.File.Exists("foo/bar.txt")).IsTrue();
+		await Expect.That(isNotified).IsTrue();
 	}
 
 	/// <summary>
 	///     Notifications allow reacting to an event after it occurred.
 	/// </summary>
 	[Fact]
-	public void Notify_UseAwaitableCallback()
+	public async Task Notify_UseAwaitableCallback()
 	{
 		bool isNotified = false;
 		MockFileSystem fileSystem = new();
@@ -53,7 +54,7 @@ public void Notify_UseAwaitableCallback()
 			// If a timeout is provided, this will throw a TimeoutException if no event was triggered within 1000ms
 			.Wait(timeout: 1000);
 
-		fileSystem.File.Exists("foo/bar.txt").Should().BeTrue();
-		isNotified.Should().BeTrue();
+		await Expect.That(fileSystem.File.Exists("foo/bar.txt")).IsTrue();
+		await Expect.That(isNotified).IsTrue();
 	}
 }

Examples/Configuration/FileSystemConfiguration.Tests/InterceptionTests.cs

@@ -32,7 +32,8 @@
 	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="AutoFixture.Xunit3" />
+		<PackageReference Include="aweXpect" />
+		<PackageReference Include="aweXpect.Testably" />
 		<PackageReference Include="Microsoft.NET.Test.Sdk" />
 		<PackageReference Include="xunit.v3" />
 		<PackageReference Include="xunit.runner.visualstudio">