chore(sonar): wrap independent assertions in Assert.Multiple (NUnit2045)

Driven by `dotnet format analyzers --diagnostics NUnit2045`. The fixer
groups consecutive independent `Assert.That(...)` calls into
`Assert.Multiple(() => { ... })`, so a failing assertion no longer
short-circuits the block — every failure inside the group is reported,
which gives much better diagnostics on multi-property tests.

Audit confirmed no Assert.Throws / Assert.Fail / Assert.Catch / Assert.Pass
/ Assert.DoesNotThrow got pulled inside a Multiple block (those need to
short-circuit). All 1180 tests pass.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownTests.cs

@@ -13,11 +13,14 @@ public class QueryBreakdownTests
         // Arrange & Act
         var queryBreakdown = new QueryBreakdown();
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(queryBreakdown.WhereClause.Clause, Is.EqualTo(string.Empty));
-        Assert.That(queryBreakdown.OrderByClause.Clause, Is.EqualTo(string.Empty));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(queryBreakdown.WhereClause.Clause, Is.EqualTo(string.Empty));
+            Assert.That(queryBreakdown.OrderByClause.Clause, Is.EqualTo(string.Empty));
+        });
     }
 
     [Test]
@@ -30,9 +33,12 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = new QueryBreakdown(selectClause, fromClause);
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(selectClause));
-        Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(fromClause));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(selectClause));
+            Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(fromClause));
+        });
     }
 
     [Test]
@@ -46,10 +52,13 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = new QueryBreakdown(selectClause, fromClause, whereClause);
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(selectClause));
-        Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(fromClause));
-        Assert.That(queryBreakdown.WhereClause.Clause, Is.EqualTo(whereClause));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(selectClause));
+            Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(fromClause));
+            Assert.That(queryBreakdown.WhereClause.Clause, Is.EqualTo(whereClause));
+        });
     }
 
     [Test]
@@ -64,11 +73,14 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = new QueryBreakdown(selectClause, fromClause, whereClause, orderByClause);
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(selectClause));
-        Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(fromClause));
-        Assert.That(queryBreakdown.WhereClause.Clause, Is.EqualTo(whereClause));
-        Assert.That(queryBreakdown.OrderByClause.Clause, Is.EqualTo(orderByClause));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo(selectClause));
+            Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo(fromClause));
+            Assert.That(queryBreakdown.WhereClause.Clause, Is.EqualTo(whereClause));
+            Assert.That(queryBreakdown.OrderByClause.Clause, Is.EqualTo(orderByClause));
+        });
     }
 
     #endregion
@@ -130,9 +142,12 @@ public class QueryBreakdownTests
         // Act
         queryBreakdown.AddParameter("userId", 123);
 
-        // Assert
-        Assert.That(queryBreakdown.Parameters.ContainsKey("userId"), Is.True);
-        Assert.That(queryBreakdown.Parameters["userId"], Is.EqualTo(123));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.Parameters.ContainsKey("userId"), Is.True);
+            Assert.That(queryBreakdown.Parameters["userId"], Is.EqualTo(123));
+        });
     }
 
     [Test]
@@ -148,9 +163,12 @@ public class QueryBreakdownTests
 
         // Assert
         Assert.That(queryBreakdown.Parameters.Count, Is.GreaterThanOrEqualTo(3));
-        Assert.That(queryBreakdown.Parameters.ContainsKey("param1"), Is.True);
-        Assert.That(queryBreakdown.Parameters.ContainsKey("param2"), Is.True);
-        Assert.That(queryBreakdown.Parameters.ContainsKey("param3"), Is.True);
+        Assert.Multiple(() =>
+        {
+            Assert.That(queryBreakdown.Parameters.ContainsKey("param1"), Is.True);
+            Assert.That(queryBreakdown.Parameters.ContainsKey("param2"), Is.True);
+            Assert.That(queryBreakdown.Parameters.ContainsKey("param3"), Is.True);
+        });
     }
 
     [Test]
@@ -182,8 +200,11 @@ public class QueryBreakdownTests
 
         // Assert
         Assert.That(queryBreakdown, Is.Not.Null);
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.Not.Empty);
-        Assert.That(queryBreakdown.FromClause.Clause, Is.Not.Empty);
+        Assert.Multiple(() =>
+        {
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.Not.Empty);
+            Assert.That(queryBreakdown.FromClause.Clause, Is.Not.Empty);
+        });
     }
 
     [Test]
@@ -195,9 +216,12 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = QueryBreakdown.Parse(sql);
 
-        // Assert
-        Assert.That(queryBreakdown.WhereClause.Clause, Is.Not.Empty);
-        Assert.That(queryBreakdown.FromClause.Clause, Does.Contain("users"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.WhereClause.Clause, Is.Not.Empty);
+            Assert.That(queryBreakdown.FromClause.Clause, Does.Contain("users"));
+        });
     }
 
     [Test]
@@ -244,13 +268,16 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = QueryBreakdown.Parse(sql);
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.Not.Empty);
-        Assert.That(queryBreakdown.FromClause.Clause, Is.Not.Empty);
-        Assert.That(queryBreakdown.WhereClause.Clause, Is.Not.Empty);
-        Assert.That(queryBreakdown.GroupByClause.Clause, Is.Not.Empty);
-        Assert.That(queryBreakdown.HavingClause.Clause, Is.Not.Empty);
-        Assert.That(queryBreakdown.OrderByClause.Clause, Is.Not.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.Not.Empty);
+            Assert.That(queryBreakdown.FromClause.Clause, Is.Not.Empty);
+            Assert.That(queryBreakdown.WhereClause.Clause, Is.Not.Empty);
+            Assert.That(queryBreakdown.GroupByClause.Clause, Is.Not.Empty);
+            Assert.That(queryBreakdown.HavingClause.Clause, Is.Not.Empty);
+            Assert.That(queryBreakdown.OrderByClause.Clause, Is.Not.Empty);
+        });
     }
 
     [Test]
@@ -262,10 +289,13 @@ public class QueryBreakdownTests
         // Act
         var success = QueryBreakdown.TryParse(sql, out var queryBreakdown, out var errorMessage);
 
-        // Assert
-        Assert.That(success, Is.True);
-        Assert.That(queryBreakdown, Is.Not.Null);
-        Assert.That(errorMessage, Is.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.True);
+            Assert.That(queryBreakdown, Is.Not.Null);
+            Assert.That(errorMessage, Is.Empty);
+        });
     }
 
     [Test]
@@ -277,9 +307,12 @@ public class QueryBreakdownTests
         // Act
         var success = QueryBreakdown.TryParse(sql, out var queryBreakdown, out var errorMessage);
 
-        // Assert
-        Assert.That(success, Is.False);
-        Assert.That(errorMessage, Is.Not.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(success, Is.False);
+            Assert.That(errorMessage, Is.Not.Empty);
+        });
     }
 
     #endregion
@@ -308,9 +341,12 @@ public class QueryBreakdownTests
         // Act
         var queryBreakdown = QueryBreakdown.Parse(sql);
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.Not.Empty);
-        Assert.That(queryBreakdown.FromClause.Clause, Is.Not.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.Not.Empty);
+            Assert.That(queryBreakdown.FromClause.Clause, Is.Not.Empty);
+        });
     }
 
     [Test]
@@ -353,9 +389,12 @@ public class QueryBreakdownTests
         queryBreakdown.SelectClause.Clause = "id, name";
         queryBreakdown.FromClause.Clause = "users";
 
-        // Assert
-        Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo("id, name"));
-        Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo("users"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(queryBreakdown.SelectClause.Clause, Is.EqualTo("id, name"));
+            Assert.That(queryBreakdown.FromClause.Clause, Is.EqualTo("users"));
+        });
     }
 
     [Test]
@@ -387,8 +426,11 @@ public class QueryBreakdownTests
 
         // Assert
         Assert.That(mainQuery.WithClauses, Has.Count.EqualTo(1));
-        Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("active_users_cte"));
-        Assert.That(mainQuery.WithClauses[0].Query, Is.EqualTo(cte));
+        Assert.Multiple(() =>
+        {
+            Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("active_users_cte"));
+            Assert.That(mainQuery.WithClauses[0].Query, Is.EqualTo(cte));
+        });
     }
 
     [Test]
@@ -448,8 +490,11 @@ public class QueryBreakdownTests
         // PostgreSQL stores parameters with positional and name-based formats
         Assert.That(merged.Count, Is.GreaterThanOrEqualTo(2));
         var keys = merged.Keys.ToList();
-        Assert.That(keys.Any(k => k.Contains("UserId")));
-        Assert.That(keys.Any(k => k.Contains("ActiveStatus")));
+        Assert.Multiple(() =>
+        {
+            Assert.That(keys.Any(k => k.Contains("UserId")));
+            Assert.That(keys.Any(k => k.Contains("ActiveStatus")));
+        });
     }
 
     [Test]
@@ -468,8 +513,11 @@ public class QueryBreakdownTests
 
         // Assert
         var keys = merged.Keys.ToList();
-        Assert.That(keys.Any(k => k.Contains("MinDate")));
-        Assert.That(keys.Any(k => k.Contains("ResultLimit")));
+        Assert.Multiple(() =>
+        {
+            Assert.That(keys.Any(k => k.Contains("MinDate")));
+            Assert.That(keys.Any(k => k.Contains("ResultLimit")));
+        });
     }
 
     [Test]
@@ -492,9 +540,12 @@ public class QueryBreakdownTests
 
         // Assert
         var keys = merged.Keys.ToList();
-        Assert.That(keys.Any(k => k.Contains("Status1")));
-        Assert.That(keys.Any(k => k.Contains("MinDate")));
-        Assert.That(keys.Any(k => k.Contains("ResultLimit")));
+        Assert.Multiple(() =>
+        {
+            Assert.That(keys.Any(k => k.Contains("Status1")));
+            Assert.That(keys.Any(k => k.Contains("MinDate")));
+            Assert.That(keys.Any(k => k.Contains("ResultLimit")));
+        });
     }
 
     [Test]
@@ -514,8 +565,11 @@ public class QueryBreakdownTests
         // Assert
         // Find the UserId parameter value
         var userIdKey = merged.Keys.FirstOrDefault(k => k.Contains("UserId") && !k.Contains('$'));
-        Assert.That(userIdKey, Is.Not.Null);
-        Assert.That(merged[userIdKey], Is.EqualTo(123)); // Main query value, not CTE value
+        Assert.Multiple(() =>
+        {
+            Assert.That(userIdKey, Is.Not.Null);
+            Assert.That(merged[userIdKey], Is.EqualTo(123)); // Main query value, not CTE value
+        });
     }
 
     [Test]
@@ -538,9 +592,12 @@ public class QueryBreakdownTests
 
         // Assert
         var keys = merged.Keys.ToList();
-        Assert.That(keys.Any(k => k.Contains("Status")), "Should include Status from nested CTE");
-        Assert.That(keys.Any(k => k.Contains("Level")), "Should include Level from middle CTE");
-        Assert.That(keys.Any(k => k.Contains("Limit")), "Should include Limit from main query");
+        Assert.Multiple(() =>
+        {
+            Assert.That(keys.Any(k => k.Contains("Status")), "Should include Status from nested CTE");
+            Assert.That(keys.Any(k => k.Contains("Level")), "Should include Level from middle CTE");
+            Assert.That(keys.Any(k => k.Contains("Limit")), "Should include Limit from main query");
+        });
     }
 
     [Test]
@@ -563,14 +620,17 @@ public class QueryBreakdownTests
         var boolKey = merged.Keys.FirstOrDefault(k => k.Contains("IsActive") && !k.Contains('$'));
         var doubleKey = merged.Keys.FirstOrDefault(k => k.Contains("Threshold") && !k.Contains('$'));
 
-        Assert.That(dateKey, Is.Not.Null);
-        Assert.That(merged[dateKey], Is.TypeOf<DateTime>());
+        Assert.Multiple(() =>
+        {
+            Assert.That(dateKey, Is.Not.Null);
+            Assert.That(merged[dateKey], Is.TypeOf<DateTime>());
 
-        Assert.That(boolKey, Is.Not.Null);
-        Assert.That(merged[boolKey], Is.TypeOf<bool>());
+            Assert.That(boolKey, Is.Not.Null);
+            Assert.That(merged[boolKey], Is.TypeOf<bool>());
 
-        Assert.That(doubleKey, Is.Not.Null);
-        Assert.That(merged[doubleKey], Is.TypeOf<double>());
+            Assert.That(doubleKey, Is.Not.Null);
+            Assert.That(merged[doubleKey], Is.TypeOf<double>());
+        });
     }
 
     #endregion