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.SqlServer.Tests/SqlServer/WithClauseTests.cs

@@ -15,11 +15,14 @@ public class WithClauseTests
         // Arrange & Act
         var withClause = new WithClause();
 
-        // Assert
-        Assert.That(withClause.TableName, Is.EqualTo(string.Empty));
-        Assert.That(withClause.Sql, Is.Null);
-        Assert.That(withClause.Query, Is.Null);
-        Assert.That(withClause.Clause, Is.Null.Or.Empty);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(withClause.TableName, Is.EqualTo(string.Empty));
+            Assert.That(withClause.Sql, Is.Null);
+            Assert.That(withClause.Query, Is.Null);
+            Assert.That(withClause.Clause, Is.Null.Or.Empty);
+        });
     }
 
     [Test]
@@ -32,10 +35,13 @@ public class WithClauseTests
         // Act
         var withClause = new WithClause(tableName, query);
 
-        // Assert
-        Assert.That(withClause.TableName, Is.EqualTo(tableName));
-        Assert.That(withClause.Query, Is.EqualTo(query));
-        Assert.That(withClause.Sql, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(withClause.TableName, Is.EqualTo(tableName));
+            Assert.That(withClause.Query, Is.EqualTo(query));
+            Assert.That(withClause.Sql, Is.Not.Null);
+        });
     }
 
     [Test]
@@ -72,10 +78,13 @@ public class WithClauseTests
         // Act
         var withClause = new WithClause(tableName, sqlClauses);
 
-        // Assert
-        Assert.That(withClause.TableName, Is.EqualTo(tableName));
-        Assert.That(withClause.Sql, Is.EqualTo(sqlClauses));
-        Assert.That(withClause.Query, Is.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(withClause.TableName, Is.EqualTo(tableName));
+            Assert.That(withClause.Sql, Is.EqualTo(sqlClauses));
+            Assert.That(withClause.Query, Is.Null);
+        });
     }
 
     [Test]
@@ -117,8 +126,11 @@ public class WithClauseTests
 
         // Assert
         Assert.That(sql, Is.Not.Null);
-        Assert.That(sql!.SelectClause?.Clause, Is.EqualTo("user_id, name"));
-        Assert.That(sql.FromClause?.Clause, Is.EqualTo("users"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(sql!.SelectClause?.Clause, Is.EqualTo("user_id, name"));
+            Assert.That(sql.FromClause?.Clause, Is.EqualTo("users"));
+        });
     }
 
     [Test]
@@ -153,9 +165,12 @@ public class WithClauseTests
         // Act
         withClause.Sql = sqlClauses;
 
-        // Assert
-        Assert.That(withClause.Sql, Is.EqualTo(sqlClauses));
-        Assert.That(withClause.Query, Is.Null);
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(withClause.Sql, Is.EqualTo(sqlClauses));
+            Assert.That(withClause.Query, Is.Null);
+        });
     }
 
     [Test]
@@ -173,12 +188,15 @@ public class WithClauseTests
         // Act
         withClause.Sql = sqlClauses;
 
-        // Assert - Clauses are applied to the Query
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("column1"));
-        Assert.That(query.FromClause.Clause, Is.EqualTo("table1"));
-        // And Sql property returns the applied clauses (from Query, not stored)
-        Assert.That(withClause.Sql?.SelectClause?.Clause, Is.EqualTo("column1"));
-        Assert.That(withClause.Sql?.FromClause?.Clause, Is.EqualTo("table1"));
+        Assert.Multiple(() =>
+        {
+            // Assert - Clauses are applied to the Query
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("column1"));
+            Assert.That(query.FromClause.Clause, Is.EqualTo("table1"));
+            // And Sql property returns the applied clauses (from Query, not stored)
+            Assert.That(withClause.Sql?.SelectClause?.Clause, Is.EqualTo("column1"));
+            Assert.That(withClause.Sql?.FromClause?.Clause, Is.EqualTo("table1"));
+        });
     }
 
     [Test]
@@ -197,9 +215,12 @@ public class WithClauseTests
         var query = new QueryBreakdown();
         withClause.Query = query;
 
-        // Assert - Stored SQL is applied to Query
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("column1"));
-        Assert.That(query.FromClause.Clause, Is.EqualTo("table1"));
+        Assert.Multiple(() =>
+        {
+            // Assert - Stored SQL is applied to Query
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("column1"));
+            Assert.That(query.FromClause.Clause, Is.EqualTo("table1"));
+        });
     }
 
     [Test]
@@ -237,10 +258,13 @@ public class WithClauseTests
         var query = new QueryBreakdown();
         withClause.Query = query;
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("old_column"));
-        Assert.That(query.FromClause.Clause, Is.EqualTo("old_table"));
-        Assert.That(withClause.Query, Is.EqualTo(query));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("old_column"));
+            Assert.That(query.FromClause.Clause, Is.EqualTo("old_table"));
+            Assert.That(withClause.Query, Is.EqualTo(query));
+        });
     }
 
     [Test]
@@ -258,9 +282,12 @@ public class WithClauseTests
         };
         withClause.Sql = sqlClauses;
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("new_column"));
-        Assert.That(query.FromClause.Clause, Is.EqualTo("new_table"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("new_column"));
+            Assert.That(query.FromClause.Clause, Is.EqualTo("new_table"));
+        });
     }
 
     #endregion
@@ -283,12 +310,15 @@ public class WithClauseTests
 
         // Assert
         Assert.That(sql, Is.Not.Null);
-        Assert.That(sql!.SelectClause?.Clause, Is.EqualTo("id, name"));
-        Assert.That(sql.FromClause?.Clause, Is.EqualTo("users"));
-        Assert.That(sql.WhereClause?.Clause, Is.EqualTo("active = 1"));
-        Assert.That(sql.GroupByClause?.Clause, Is.EqualTo("department"));
-        Assert.That(sql.HavingClause?.Clause, Is.EqualTo("COUNT(*) > 5"));
-        Assert.That(sql.OrderByClause?.Clause, Is.EqualTo("name ASC"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(sql!.SelectClause?.Clause, Is.EqualTo("id, name"));
+            Assert.That(sql.FromClause?.Clause, Is.EqualTo("users"));
+            Assert.That(sql.WhereClause?.Clause, Is.EqualTo("active = 1"));
+            Assert.That(sql.GroupByClause?.Clause, Is.EqualTo("department"));
+            Assert.That(sql.HavingClause?.Clause, Is.EqualTo("COUNT(*) > 5"));
+            Assert.That(sql.OrderByClause?.Clause, Is.EqualTo("name ASC"));
+        });
     }
 
     #endregion
@@ -315,13 +345,16 @@ public class WithClauseTests
         // Act
         withClause.Sql = sqlClauses;
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("id, name"));
-        Assert.That(query.FromClause.Clause, Is.EqualTo("users"));
-        Assert.That(query.WhereClause.Clause, Is.EqualTo("active = 1"));
-        Assert.That(query.GroupByClause.Clause, Is.EqualTo("department"));
-        Assert.That(query.HavingClause.Clause, Is.EqualTo("COUNT(*) > 5"));
-        Assert.That(query.OrderByClause.Clause, Is.EqualTo("name ASC"));
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("id, name"));
+            Assert.That(query.FromClause.Clause, Is.EqualTo("users"));
+            Assert.That(query.WhereClause.Clause, Is.EqualTo("active = 1"));
+            Assert.That(query.GroupByClause.Clause, Is.EqualTo("department"));
+            Assert.That(query.HavingClause.Clause, Is.EqualTo("COUNT(*) > 5"));
+            Assert.That(query.OrderByClause.Clause, Is.EqualTo("name ASC"));
+        });
     }
 
     [Test]
@@ -340,9 +373,12 @@ public class WithClauseTests
         // Act
         withClause.Sql = sqlClauses;
 
-        // Assert
-        Assert.That(query.SelectClause.Clause, Is.EqualTo("new_select"));
-        Assert.That(query.FromClause.Clause, Is.EqualTo("original_from")); // Unchanged
+        Assert.Multiple(() =>
+        {
+            // Assert
+            Assert.That(query.SelectClause.Clause, Is.EqualTo("new_select"));
+            Assert.That(query.FromClause.Clause, Is.EqualTo("original_from")); // Unchanged
+        });
     }
 
     #endregion
@@ -448,14 +484,17 @@ public class WithClauseTests
         var innerSql = innerCte.Sql;
         var outerSql = outerCte.Sql;
 
-        // Assert - Inner CTE has parameter and correct clauses
-        Assert.That(innerQuery.ParameterList.Count(), Is.EqualTo(1));
-        Assert.That(innerSql?.SelectClause?.Clause, Is.EqualTo("id, name"));
-        Assert.That(innerSql?.WhereClause?.Clause, Is.EqualTo("created_date >= @StartDate"));
+        Assert.Multiple(() =>
+        {
+            // Assert - Inner CTE has parameter and correct clauses
+            Assert.That(innerQuery.ParameterList.Count(), Is.EqualTo(1));
+            Assert.That(innerSql?.SelectClause?.Clause, Is.EqualTo("id, name"));
+            Assert.That(innerSql?.WhereClause?.Clause, Is.EqualTo("created_date >= @StartDate"));
 
-        // Assert - Outer CTE references inner CTE
-        Assert.That(outerSql?.SelectClause?.Clause, Is.EqualTo("*"));
-        Assert.That(outerSql?.FromClause?.Clause, Is.EqualTo("recent_users"));
+            // Assert - Outer CTE references inner CTE
+            Assert.That(outerSql?.SelectClause?.Clause, Is.EqualTo("*"));
+            Assert.That(outerSql?.FromClause?.Clause, Is.EqualTo("recent_users"));
+        });
     }
 
     [Test]
@@ -495,9 +534,12 @@ public class WithClauseTests
         Assert.That(sql, Does.Contain("WITH"));
         Assert.That(sql, Does.Contain("active_users"));
         Assert.That(sql, Does.Contain("AS"));
-        // Check for keywords/content (allowing for formatting variations)
-        Assert.That(sql.ToUpper(), Does.Contain("SELECT"));
-        Assert.That(sql, Does.Contain("id, name"));
+        Assert.Multiple(() =>
+        {
+            // Check for keywords/content (allowing for formatting variations)
+            Assert.That(sql.ToUpper(), Does.Contain("SELECT"));
+            Assert.That(sql, Does.Contain("id, name"));
+        });
         Assert.That(sql, Does.Contain("users"));
         Assert.That(sql, Does.Contain("active = 1"));
     }
@@ -523,8 +565,11 @@ public class WithClauseTests
         // Verify order: first CTE comes before second CTE
         var pos1 = sql.IndexOf("active_users");
         var pos2 = sql.IndexOf("user_orders");
-        Assert.That(pos1, Is.GreaterThan(-1));
-        Assert.That(pos2, Is.GreaterThan(-1));
+        Assert.Multiple(() =>
+        {
+            Assert.That(pos1, Is.GreaterThan(-1));
+            Assert.That(pos2, Is.GreaterThan(-1));
+        });
         Assert.That(pos1, Is.LessThan(pos2));    }
 
     #endregion