fix: Address TUnit migration issues from code review

- Fix 8 NRE occurrences in MarkdownChunkingServiceTests.cs: replace
  FirstOrDefault + .Header access with Assert.That(sections).Contains(predicate)
- Remove redundant string.Join assertion (line 208) in MarkdownChunkingServiceTests.cs
- Remove #pragma CA1707 disable/restore from MarkdownChunkingServiceTests.cs
- Add CA1707 suppression to .editorconfig for test projects (replaces csproj NoWarn)
- Remove <NoWarn>CA1707</NoWarn> from Web.Tests.csproj
- Update TUnit 1.17.11 -> 1.17.20 in Directory.Packages.props
- Add [NotInParallel('FunctionalTests')] to fix parallel SQLite transaction conflict:
  XUnit ran tests sequentially within a class; TUnit runs in parallel, causing
  multiple EF Core operations to call BeginTransaction on the same SQLite
  connection simultaneously
- Add --coverage to CI dotnet test command (replaces removed coverlet.collector)
- Add [Timeout(30_000)] with CancellationToken to CaptchaService_Verify_Success
- Standardize StringComparison.OrdinalIgnoreCase in SitemapXmlHelpersTests URL predicates
- Wrap foreach assertions with Assert.Multiple() in ListingSourceCode tests
- Add IAsyncInitializer to WebApplicationFactory for eager server initialization

Author: BenjaminMichaelis

.editorconfig

@@ -156,4 +156,7 @@ csharp_style_expression_bodied_lambdas = true:silent
 csharp_style_expression_bodied_local_functions = false:silent
 
 # CA1848: Use the LoggerMessage delegates
-dotnet_diagnostic.CA1848.severity = suggestion
+dotnet_diagnostic.CA1848.severity = suggestion
+# Test files - allow underscore-separated test method names (CA1707)
+[{EssentialCSharp.Web.Tests,EssentialCSharp.Chat.Tests}/**]
+dotnet_diagnostic.CA1707.severity = none

.github/workflows/PR-Build-And-Test.yml

@@ -35,7 +35,7 @@ jobs:
         run: dotnet build --configuration Release --no-restore /p:AccessToNugetFeed=false
 
       - name: Run .NET Tests
-        run: dotnet test --no-build --configuration Release --report-trx --results-directory ${{ runner.temp }}
+        run: dotnet test --no-build --configuration Release --report-trx --coverage --results-directory ${{ runner.temp }}
 
       - name: Convert TRX to VS Playlist
         if: failure()

Directory.Packages.props

@@ -21,7 +21,7 @@
     <PackageVersion Include="Azure.Identity" Version="1.17.1" />
     <PackageVersion Include="Azure.Monitor.OpenTelemetry.AspNetCore" Version="1.4.0" />
     <PackageVersion Include="Microsoft.ApplicationInsights.Profiler.AspNetCore" Version="3.0.1" />
-    <PackageVersion Include="TUnit" Version="1.17.11" />
+    <PackageVersion Include="TUnit" Version="1.17.20" />
     <PackageVersion Include="EssentialCSharp.Shared.Models" Version="$(ToolingPackagesVersion)" />
     <PackageVersion Include="HtmlAgilityPack" Version="1.12.4" />
     <PackageVersion Include="IntelliTect.Multitool" Version="1.5.3" />

EssentialCSharp.Chat.Tests/MarkdownChunkingServiceTests.cs

@@ -2,8 +2,7 @@
 using Moq;
 
 namespace EssentialCSharp.Chat.Tests;
-// TODO: Move to editorconfig later, just moving quick
-#pragma warning disable CA1707 // Identifiers should not contain underscores
+
 public class MarkdownChunkingServiceTests
 {
     #region MarkdownContentToHeadersAndSection
@@ -44,18 +43,12 @@ publicstaticvoid Main()       // Method declaration
         var sections = MarkdownChunkingService.MarkdownContentToHeadersAndSection(markdown);
 
         await Assert.That(sections.Count).IsEqualTo(3);
-        var beginnerSection = sections.FirstOrDefault(s => s.Header == "Beginner Topic: What Is a Method?");
-        await Assert.That(beginnerSection.Header).IsNotNull();
-        await Assert.That(string.Join("\n", beginnerSection.Content)).Contains("Syntactically, a **method** in C# is a named block of code");
-
-        var mainMethodSection = sections.FirstOrDefault(s => s.Header == "Main Method");
-        await Assert.That(mainMethodSection.Header).IsNotNull();
-        await Assert.That(string.Join("\n", mainMethodSection.Content)).Contains("The location where C# programs begin execution is the **Main method**, which begins with `static void Main()`");
-        await Assert.That(string.Join("\n", mainMethodSection.Content)).Contains("publicclass Program");
-
-        var advancedTopicSection = sections.FirstOrDefault(s => s.Header == "Main Method: Advanced Topic: Declaration of the Main Method");
-        await Assert.That(advancedTopicSection.Header).IsNotNull();
-        await Assert.That(string.Join("\n", advancedTopicSection.Content)).Contains("C# requires that the Main method return either `void` or `int`");
+        await Assert.That(sections).Contains(s => s.Header == "Beginner Topic: What Is a Method?" && string.Join("\n", s.Content).Contains("Syntactically, a **method** in C# is a named block of code"));
+
+        await Assert.That(sections).Contains(s => s.Header == "Main Method" && string.Join("\n", s.Content).Contains("The location where C# programs begin execution is the **Main method**, which begins with `static void Main()`"));
+        await Assert.That(sections).Contains(s => s.Header == "Main Method" && string.Join("\n", s.Content).Contains("publicclass Program"));
+
+        await Assert.That(sections).Contains(s => s.Header == "Main Method: Advanced Topic: Declaration of the Main Method" && string.Join("\n", s.Content).Contains("C# requires that the Main method return either `void` or `int`"));
     }
 
     [Test]
@@ -96,9 +89,7 @@ publicstaticvoid Main()
 
         await Assert.That(sections.Count).IsEqualTo(2);
         // The code listing should be appended to the Working with Variables section, not as its own section
-        var workingWithVariablesSection = sections.FirstOrDefault(s => s.Header == "Working with Variables");
-        await Assert.That(workingWithVariablesSection.Header).IsNotNull().And.IsNotEmpty();
-        await Assert.That(string.Join("\n", workingWithVariablesSection.Content)).Contains("publicclass MiracleMax");
+        await Assert.That(sections).Contains(s => s.Header == "Working with Variables" && string.Join("\n", s.Content).Contains("publicclass MiracleMax"));
         await Assert.That(sections).DoesNotContain(s => s.Header == "Listing 1.12: Declaring and Assigning a Variable");
     }
 
@@ -153,25 +144,15 @@ publicstaticvoid Main()
         var sections = MarkdownChunkingService.MarkdownContentToHeadersAndSection(markdown);
         await Assert.That(sections.Count).IsEqualTo(5);
 
-        var beginnerDataTypeSection = sections.FirstOrDefault(s => s.Header == "Beginner Topic: What Is a Data Type?");
-        await Assert.That(beginnerDataTypeSection.Header).IsNotNull();
-        await Assert.That(string.Join("\n", beginnerDataTypeSection.Content)).Contains("The type of data that a variable declaration specifies is called a **data type**");
+        await Assert.That(sections).Contains(s => s.Header == "Beginner Topic: What Is a Data Type?" && string.Join("\n", s.Content).Contains("The type of data that a variable declaration specifies is called a **data type**"));
 
-        var declaringSection = sections.FirstOrDefault(s => s.Header == "Declaring a Variable");
-        await Assert.That(declaringSection.Header).IsNotNull();
-        await Assert.That(string.Join("\n", declaringSection.Content)).Contains("In Listing 1.12, `string max` is a variable declaration");
+        await Assert.That(sections).Contains(s => s.Header == "Declaring a Variable" && string.Join("\n", s.Content).Contains("In Listing 1.12, `string max` is a variable declaration"));
 
-        var declaringAnotherSection = sections.FirstOrDefault(s => s.Header == "Declaring a Variable: Declaring another thing");
-        await Assert.That(declaringAnotherSection.Header).IsNotNull();
-        await Assert.That(string.Join("\n", declaringAnotherSection.Content)).Contains("Because a multivariable declaration statement allows developers to provide the data type only once");
+        await Assert.That(sections).Contains(s => s.Header == "Declaring a Variable: Declaring another thing" && string.Join("\n", s.Content).Contains("Because a multivariable declaration statement allows developers to provide the data type only once"));
 
-        var assigningSection = sections.FirstOrDefault(s => s.Header == "Assigning a Variable");
-        await Assert.That(assigningSection.Header).IsNotNull();
-        await Assert.That(string.Join("\n", assigningSection.Content)).Contains("After declaring a local variable, you must assign it a value before reading from it.");
+        await Assert.That(sections).Contains(s => s.Header == "Assigning a Variable" && string.Join("\n", s.Content).Contains("After declaring a local variable, you must assign it a value before reading from it."));
 
-        var continuedLearningSection = sections.FirstOrDefault(s => s.Header == "Assigning a Variable: Continued Learning");
-        await Assert.That(continuedLearningSection.Header).IsNotNull();
-        await Assert.That(string.Join("\n", continuedLearningSection.Content)).Contains("From this listing, observe that it is possible to assign a variable as part of the variable declaration");
+        await Assert.That(sections).Contains(s => s.Header == "Assigning a Variable: Continued Learning" && string.Join("\n", s.Content).Contains("From this listing, observe that it is possible to assign a variable as part of the variable declaration"));
     }
     #endregion MarkdownContentToHeadersAndSection
 
@@ -205,10 +186,7 @@ public async Task ProcessSingleMarkdownFile_ProducesExpectedChunksAndHeaders()
         await Assert.That(result.FilePath).IsEqualTo(filePath);
         await Assert.That(string.Join("\n", result.Chunks)).Contains("This is the first section.");
         await Assert.That(string.Join("\n", result.Chunks)).Contains("Console.WriteLine(\"Hello World\");");
-        await Assert.That(string.Join("\n", result.Chunks)).Contains("This is the second section.");
         await Assert.That(result.Chunks).Contains(c => c.Contains("This is the second section."));
     }
     #endregion ProcessSingleMarkdownFile
 }
-
-#pragma warning restore CA1707 // Identifiers should not contain underscores

EssentialCSharp.Web.Tests/EssentialCSharp.Web.Tests.csproj

@@ -5,10 +5,6 @@
 
     <IsPackable>false</IsPackable>
     <IsPublishable>false</IsPublishable>
-    <!--
-    CA1707, Identifiers should not contain underscores - we allow these in test names
-    -->
-    <NoWarn>$(NoWarn);CA1707</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>

EssentialCSharp.Web.Tests/FunctionalTests.cs

@@ -2,6 +2,7 @@
 
 namespace EssentialCSharp.Web.Tests;
 
+[NotInParallel("FunctionalTests")]
 [ClassDataSource<WebApplicationFactory>(Shared = SharedType.PerClass)]
 public class FunctionalTests(WebApplicationFactory factory)
 {

EssentialCSharp.Web.Tests/Integration/CaptchaTests.cs

@@ -9,7 +9,8 @@ namespace EssentialCSharp.Web.Extensions.Tests.Integration;
 public class CaptchaTests(CaptchaServiceProvider serviceProvider)
 {
     [Test]
-    public async Task CaptchaService_Verify_Success()
+    [Timeout(30_000)]
+    public async Task CaptchaService_Verify_Success(CancellationToken cancellationToken)
     {
         ICaptchaService captchaService = serviceProvider.ServiceProvider.GetRequiredService<ICaptchaService>();
 

EssentialCSharp.Web.Tests/ListingSourceCodeControllerTests.cs

@@ -76,7 +76,10 @@ public async Task GetListingsByChapter_WithValidChapter_ReturnsMultipleListings(
         // Verify all results are from chapter 1
         foreach (var r in results)
         {
-            await Assert.That(r.ChapterNumber).IsEqualTo(1);
+            using (Assert.Multiple())
+            {
+                await Assert.That(r.ChapterNumber).IsEqualTo(1);
+            }
         }
 
         // Verify results are ordered by listing number
@@ -85,8 +88,11 @@ public async Task GetListingsByChapter_WithValidChapter_ReturnsMultipleListings(
         // Verify each listing has required properties
         foreach (var r in results)
         {
-            await Assert.That(r.FileExtension).IsNotEmpty();
-            await Assert.That(r.Content).IsNotEmpty();
+            using (Assert.Multiple())
+            {
+                await Assert.That(r.FileExtension).IsNotEmpty();
+                await Assert.That(r.Content).IsNotEmpty();
+            }
         }
     }
 

EssentialCSharp.Web.Tests/ListingSourceCodeServiceTests.cs

@@ -82,9 +82,12 @@ public async Task GetListingsByChapterAsync_WithValidChapter_ReturnsAllListings(
         await Assert.That(results).IsNotEmpty();
         foreach (var r in results)
         {
-            await Assert.That(r.ChapterNumber).IsEqualTo(1);
-            await Assert.That(r.Content).IsNotEmpty();
-            await Assert.That(r.FileExtension).IsNotEmpty();
+            using (Assert.Multiple())
+            {
+                await Assert.That(r.ChapterNumber).IsEqualTo(1);
+                await Assert.That(r.Content).IsNotEmpty();
+                await Assert.That(r.FileExtension).IsNotEmpty();
+            }
         }
 
         // Verify results are ordered
@@ -106,8 +109,11 @@ public async Task GetListingsByChapterAsync_DirectoryContainsNonListingFiles_Exc
         // Ensure all results match the {CC}.{LL}.{ext} pattern
         foreach (var r in results)
         {
-            await Assert.That(r.ChapterNumber).IsEqualTo(10);
-            await Assert.That(r.ListingNumber).IsBetween(1, 99);
+            using (Assert.Multiple())
+            {
+                await Assert.That(r.ChapterNumber).IsEqualTo(10);
+                await Assert.That(r.ListingNumber).IsBetween(1, 99);
+            }
         }
     }
 

EssentialCSharp.Web.Tests/SitemapXmlHelpersTests.cs

@@ -147,9 +147,9 @@ public async Task GenerateSitemapXml_IncludesSiteMappingsMarkedForXml()
 
         var allUrls = nodes.Select(n => n.Url).ToList();
 
-        await Assert.That(allUrls).Contains(url => url.Contains("test-page-1"));
-        await Assert.That(allUrls).DoesNotContain(url => url.Contains("test-page-2")); // Not marked for XML
-        await Assert.That(allUrls).Contains(url => url.Contains("test-page-3"));
+        await Assert.That(allUrls).Contains(url => url.Contains("test-page-1", StringComparison.OrdinalIgnoreCase));
+        await Assert.That(allUrls).DoesNotContain(url => url.Contains("test-page-2", StringComparison.OrdinalIgnoreCase)); // Not marked for XML
+        await Assert.That(allUrls).Contains(url => url.Contains("test-page-3", StringComparison.OrdinalIgnoreCase));
     }
 
     [Test]