Make test project AOT-compatible: migrate to TUnit.Mocks and TUnit built-in assertions (#42)

* Initial plan

* Initial plan for AOT compatibility and test framework migration

Co-authored-by: Kumara-Krishnan <5687650+Kumara-Krishnan@users.noreply.github.com>

* Migrate from NSubstitute to TUnit.Mocks and from AwesomeAssertions to TUnit built-in Assert; enable AOT in tests

Co-authored-by: Kumara-Krishnan <5687650+Kumara-Krishnan@users.noreply.github.com>

* Update test instructions to reflect TUnit.Mocks and TUnit built-in Assert migration

Co-authored-by: Kumara-Krishnan <5687650+Kumara-Krishnan@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: Kumara-Krishnan <5687650+Kumara-Krishnan@users.noreply.github.com>

Author: Copilot

.github/instructions/tests.instructions.md

@@ -17,10 +17,10 @@ For the canonical, authoritative test guidance see:
 | Library | Purpose |
 |---|---|
 | **TUnit** | Test framework — use `[Test]`, `[Before(Test)]`, `[After(Test)]`, `[Category("…")]` |
-| **AwesomeAssertions** | Assertions — `using AwesomeAssertions;` |
-| **NSubstitute** | Mocking — `Substitute.For<T>()`, `.Returns()`, `.Received()` |
+| **TUnit Assertions** | Built-in assertions — `await Assert.That(value).IsEqualTo(expected)` |
+| **TUnit.Mocks** | AOT-compatible source-generated mocking — `Mock.Of<T>()`, `.Returns()`, `.WasCalled()` |
 
-**Never** use xUnit, NUnit, MSTest, FluentAssertions, Moq, or raw `Assert.*`.
+**Never** use xUnit, NUnit, MSTest, FluentAssertions, AwesomeAssertions, Moq, NSubstitute, or raw `Assert.*`.
 
 ---
 
@@ -65,12 +65,12 @@ public class FileSystemAdapterTests { … }
 ### Unit tests — mock in `[Before(Test)]`, use `null!` fields
 
 ```csharp
-private ISomeDependency _dep = null!;
+private Mock<ISomeDependency> _dep = null!;
 
 [Before(Test)]
 public void Setup()
 {
-    _dep = Substitute.For<ISomeDependency>();
+    _dep = Mock.Of<ISomeDependency>();
 }
 ```
 
@@ -101,22 +101,39 @@ Never share a `ServiceProvider` between tests.
 
 ### Assertion style
 
-- `.Should().BeSameAs()` — reference equality (mock instance)
-- `.Should().Be()` — value equality
-- `await act.Should().ThrowAsync<TException>()` — for async exception assertions
+All assertions are async and must be awaited:
+
+- `await Assert.That(actual).IsEqualTo(expected)` — value equality
+- `await Assert.That(actual).IsSameReferenceAs(expected)` — reference equality (mock instance)
+- `await Assert.That(actual).IsNotNull()` — null checks
+- `await Assert.That(actual).IsTrue()` / `.IsFalse()` — boolean assertions
+- `await Assert.That(act).Throws<TException>()` — exception assertions
+- `await Assert.That(act).ThrowsNothing()` — no-throw assertions
 - Assign the `act` lambda before asserting: `var act = async () => await …;`
 
-### Exception propagation
+### Mock setup and verification
 
 ```csharp
-_dep.SomeMethod(Arg.Any<string>())
-    .Returns<T>(x => throw new InvalidOperationException("…"));
+// Setup return values
+_dep.SomeMethod(Any<string>()).Returns(expectedValue);
+
+// Setup exceptions
+_dep.SomeMethod(Any<string>()).Throws(new InvalidOperationException("…"));
+
+// Setup callbacks
+_dep.SomeMethod(Any<string>()).Callback(() => { /* side effect */ });
+
+// Verify calls
+_dep.SomeMethod("arg").WasCalled(Times.Once);
+_dep.SomeMethod(Any<string>()).WasNeverCalled();
 ```
 
-### Verify call counts
+### Argument matchers
 
-- `_dep.Received(1).Method(…)` — expected exactly once
-- `_dep.DidNotReceive().Method(…)` — must not be called
+- `Any()` or `Any<T>()` — match any argument
+- `Is<T>(predicate)` — match with predicate
+- `IsNull<T>()` — match null values
+- Raw values — exact match
 
 ---
 

Cyclotron.Tests/Cyclotron.Tests.csproj

@@ -6,16 +6,11 @@
     <Nullable>enable</Nullable>
     <IsPackable>false</IsPackable>
     <IsTestProject>true</IsTestProject>
-    <IsAotCompatible>false</IsAotCompatible>
-    <IsTrimmable>false</IsTrimmable>
-    <EnableTrimAnalyzer>false</EnableTrimAnalyzer>
-    <EnableSingleFileAnalyzer>false</EnableSingleFileAnalyzer>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="TUnit" />
-    <PackageReference Include="NSubstitute" />
-    <PackageReference Include="AwesomeAssertions" />
+    <PackageReference Include="TUnit.Mocks" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" />
     <PackageReference Include="Coverlet.Collector" />
     <PackageReference Include="Coverlet.MSBuild" />

Cyclotron.Tests/Integration/FileSystemAdapter/FileSystemAdapterIntegrationTests.cs

@@ -1,6 +1,5 @@
 using Cyclotron.Tests.Integration.Fixtures;
 using Cyclotron.Tests.TestHelpers;
-using AwesomeAssertions;
 
 namespace Cyclotron.Tests.Integration.FileSystemAdapter;
 
@@ -33,7 +32,7 @@ public async Task WriteAllTextAsync_ThenReadAllTextAsync_ReturnsSameContent()
         await File.WriteAllTextAsync(filePath, content);
         var readContent = await File.ReadAllTextAsync(filePath);
 
-        readContent.Should().Be(content);
+        await Assert.That(readContent).IsEqualTo(content);
     }
 
     [Test]
@@ -45,7 +44,7 @@ public async Task WriteAllTextAsync_WithUtf8Encoding_PreservesContent()
         await File.WriteAllTextAsync(filePath, content, System.Text.Encoding.UTF8);
         var readContent = await File.ReadAllTextAsync(filePath, System.Text.Encoding.UTF8);
 
-        readContent.Should().Be(content);
+        await Assert.That(readContent).IsEqualTo(content);
     }
 
     [Test]
@@ -57,7 +56,7 @@ public async Task WriteAllBytesAsync_ThenReadAllBytesAsync_PreservesBinaryData()
         await File.WriteAllBytesAsync(filePath, bytes);
         var readBytes = await File.ReadAllBytesAsync(filePath);
 
-        readBytes.Should().BeEquivalentTo(bytes);
+        await Assert.That(readBytes).IsEquivalentTo(bytes);
     }
 
     [Test]
@@ -69,7 +68,7 @@ public async Task WriteAllBytesAsync_EmptyArray_CreatesEmptyFile()
         await File.WriteAllBytesAsync(filePath, bytes);
         var readBytes = await File.ReadAllBytesAsync(filePath);
 
-        readBytes.Should().BeEmpty();
+        await Assert.That(readBytes).IsEmpty();
     }
 
     #endregion
@@ -82,51 +81,51 @@ public async Task FileExists_ReturnsTrue_WhenFileExists()
         var filePath = _fixture.GetTempFilePath("exists.txt");
         await File.WriteAllTextAsync(filePath, "content");
 
-        File.Exists(filePath).Should().BeTrue();
+        await Assert.That(File.Exists(filePath)).IsTrue();
     }
 
     [Test]
-    public void FileExists_ReturnsFalse_WhenFileDoesNotExist()
+    public async Task FileExists_ReturnsFalse_WhenFileDoesNotExist()
     {
         var filePath = _fixture.GetTempFilePath("nonexistent.txt");
 
-        File.Exists(filePath).Should().BeFalse();
+        await Assert.That(File.Exists(filePath)).IsFalse();
     }
 
     #endregion
 
     #region Directory Operations
 
     [Test]
-    public void CreateDirectory_CreatesNestedDirectories()
+    public async Task CreateDirectory_CreatesNestedDirectories()
     {
         var dirPath = Path.Combine(_fixture.RootPath, "level1", "level2", "level3");
 
         Directory.CreateDirectory(dirPath);
 
-        Directory.Exists(dirPath).Should().BeTrue();
+        await Assert.That(Directory.Exists(dirPath)).IsTrue();
     }
 
     [Test]
-    public void CreateDirectory_IsIdempotent()
+    public async Task CreateDirectory_IsIdempotent()
     {
         var dirPath = _fixture.GetTempDirectoryPath("idempotent");
 
         Directory.CreateDirectory(dirPath);
         Directory.CreateDirectory(dirPath);
 
-        Directory.Exists(dirPath).Should().BeTrue();
+        await Assert.That(Directory.Exists(dirPath)).IsTrue();
     }
 
     [Test]
-    public void DeleteDirectory_RemovesEmptyDirectory()
+    public async Task DeleteDirectory_RemovesEmptyDirectory()
     {
         var dirPath = _fixture.GetTempDirectoryPath("todelete");
         Directory.CreateDirectory(dirPath);
 
         Directory.Delete(dirPath);
 
-        Directory.Exists(dirPath).Should().BeFalse();
+        await Assert.That(Directory.Exists(dirPath)).IsFalse();
     }
 
     [Test]
@@ -139,7 +138,7 @@ public async Task DeleteDirectory_Recursive_RemovesNestedContent()
 
         Directory.Delete(dirPath, recursive: true);
 
-        Directory.Exists(dirPath).Should().BeFalse();
+        await Assert.That(Directory.Exists(dirPath)).IsFalse();
     }
 
     [Test]
@@ -153,18 +152,18 @@ public async Task EnumerateFiles_ReturnsCorrectFiles()
 
         var txtFiles = Directory.EnumerateFiles(dirPath, "*.txt").ToList();
 
-        txtFiles.Should().HaveCount(2);
+        await Assert.That(txtFiles).Count().IsEqualTo(2);
     }
 
     [Test]
-    public void EnumerateFiles_EmptyDirectory_ReturnsEmpty()
+    public async Task EnumerateFiles_EmptyDirectory_ReturnsEmpty()
     {
         var dirPath = _fixture.GetTempDirectoryPath("empty");
         Directory.CreateDirectory(dirPath);
 
         var files = Directory.EnumerateFiles(dirPath).ToList();
 
-        files.Should().BeEmpty();
+        await Assert.That(files).IsEmpty();
     }
 
     [Test]
@@ -178,7 +177,7 @@ public async Task EnumerateFiles_Recursive_TraversesSubdirectories()
 
         var files = Directory.EnumerateFiles(dirPath, "*.*", SearchOption.AllDirectories).ToList();
 
-        files.Should().HaveCount(2);
+        await Assert.That(files).Count().IsEqualTo(2);
     }
 
     #endregion
@@ -195,8 +194,8 @@ public async Task FileCopy_CreatesIdenticalCopy()
 
         File.Copy(sourcePath, destPath);
 
-        File.Exists(destPath).Should().BeTrue();
-        (await File.ReadAllTextAsync(destPath)).Should().Be(content);
+        await Assert.That(File.Exists(destPath)).IsTrue();
+        await Assert.That(await File.ReadAllTextAsync(destPath)).IsEqualTo(content);
     }
 
     [Test]
@@ -208,8 +207,8 @@ public async Task FileMove_MovesFileToNewLocation()
 
         File.Move(sourcePath, destPath);
 
-        File.Exists(sourcePath).Should().BeFalse();
-        File.Exists(destPath).Should().BeTrue();
+        await Assert.That(File.Exists(sourcePath)).IsFalse();
+        await Assert.That(File.Exists(destPath)).IsTrue();
     }
 
     [Test]
@@ -220,7 +219,7 @@ public async Task FileDelete_RemovesFileFromDisk()
 
         File.Delete(filePath);
 
-        File.Exists(filePath).Should().BeFalse();
+        await Assert.That(File.Exists(filePath)).IsFalse();
     }
 
     [Test]
@@ -236,9 +235,9 @@ public async Task FileMove_AcrossDirectories_Works()
 
         File.Move(sourcePath, destPath);
 
-        File.Exists(sourcePath).Should().BeFalse();
-        File.Exists(destPath).Should().BeTrue();
-        (await File.ReadAllTextAsync(destPath)).Should().Be("cross-dir move");
+        await Assert.That(File.Exists(sourcePath)).IsFalse();
+        await Assert.That(File.Exists(destPath)).IsTrue();
+        await Assert.That(await File.ReadAllTextAsync(destPath)).IsEqualTo("cross-dir move");
     }
 
     #endregion
@@ -251,8 +250,8 @@ public async Task FileOperations_WithSpacesInName_Work()
         var filePath = _fixture.GetTempFilePath("file with spaces.txt");
         await File.WriteAllTextAsync(filePath, "content");
 
-        File.Exists(filePath).Should().BeTrue();
-        (await File.ReadAllTextAsync(filePath)).Should().Be("content");
+        await Assert.That(File.Exists(filePath)).IsTrue();
+        await Assert.That(await File.ReadAllTextAsync(filePath)).IsEqualTo("content");
     }
 
     [Test]
@@ -261,32 +260,32 @@ public async Task FileOperations_WithUnicodeInName_Work()
         var filePath = _fixture.GetTempFilePath("файл_données_数据.txt");
         await File.WriteAllTextAsync(filePath, "unicode content");
 
-        File.Exists(filePath).Should().BeTrue();
-        (await File.ReadAllTextAsync(filePath)).Should().Be("unicode content");
+        await Assert.That(File.Exists(filePath)).IsTrue();
+        await Assert.That(await File.ReadAllTextAsync(filePath)).IsEqualTo("unicode content");
     }
 
     #endregion
 
     #region Error Scenarios
 
     [Test]
-    public void ReadNonExistentFile_ThrowsFileNotFoundException()
+    public async Task ReadNonExistentFile_ThrowsFileNotFoundException()
     {
         var filePath = _fixture.GetTempFilePath("nonexistent.txt");
 
         var act = () => File.ReadAllText(filePath);
 
-        act.Should().Throw<FileNotFoundException>();
+        await Assert.That(act).Throws<FileNotFoundException>();
     }
 
     [Test]
-    public void DeleteNonExistentFile_DoesNotThrow()
+    public async Task DeleteNonExistentFile_DoesNotThrow()
     {
         var filePath = _fixture.GetTempFilePath("nonexistent.txt");
 
         var act = () => File.Delete(filePath);
 
-        act.Should().NotThrow();
+        await Assert.That(act).ThrowsNothing();
     }
 
     #endregion
@@ -305,7 +304,7 @@ public async Task ParallelWrites_ToDifferentFiles_AllSucceed()
         await Task.WhenAll(tasks);
 
         var files = Directory.EnumerateFiles(_fixture.RootPath, "parallel_*.txt").ToList();
-        files.Should().HaveCount(50);
+        await Assert.That(files).Count().IsEqualTo(50);
     }
 
     [Test]
@@ -322,41 +321,41 @@ public async Task ParallelReads_FromSameFile_AllSucceed()
         });
 
         var results = await Task.WhenAll(tasks);
-        results.Should().AllBe(content);
+        await Assert.That(results.All(r => r == content)).IsTrue();
     }
 
     #endregion
 
     #region TempFileSystemFixture Tests
 
     [Test]
-    public void Fixture_CreatesRootDirectory()
+    public async Task Fixture_CreatesRootDirectory()
     {
-        Directory.Exists(_fixture.RootPath).Should().BeTrue();
+        await Assert.That(Directory.Exists(_fixture.RootPath)).IsTrue();
     }
 
     [Test]
-    public void Fixture_GetTempFilePath_ReturnsPathInRootDirectory()
+    public async Task Fixture_GetTempFilePath_ReturnsPathInRootDirectory()
     {
         var path = _fixture.GetTempFilePath();
 
-        Path.GetDirectoryName(path).Should().Be(_fixture.RootPath);
+        await Assert.That(Path.GetDirectoryName(path)).IsEqualTo(_fixture.RootPath);
     }
 
     [Test]
-    public void Fixture_GetTempFilePath_WithCustomName_UsesProvidedName()
+    public async Task Fixture_GetTempFilePath_WithCustomName_UsesProvidedName()
     {
         var path = _fixture.GetTempFilePath("custom.txt");
 
-        Path.GetFileName(path).Should().Be("custom.txt");
+        await Assert.That(Path.GetFileName(path)).IsEqualTo("custom.txt");
     }
 
     [Test]
-    public void Fixture_GetTempDirectoryPath_ReturnsPathInRootDirectory()
+    public async Task Fixture_GetTempDirectoryPath_ReturnsPathInRootDirectory()
     {
         var path = _fixture.GetTempDirectoryPath();
 
-        Path.GetDirectoryName(path).Should().Be(_fixture.RootPath);
+        await Assert.That(Path.GetDirectoryName(path)).IsEqualTo(_fixture.RootPath);
     }
 
     #endregion