chore(sonar): clear residual test-file smells (NUnit2046, NUnit2045, CS8604)

- **NUnit2046 (15)**: extend the prior regex sweep to also catch the
  `Is.GreaterThan(n)` / `Is.GreaterThanOrEqualTo(n)` variants on
  `.Count` and `.Length` — the previous pass only handled `Is.EqualTo`.
  Affects PG/Snowflake `QueryBreakdownTests`, PG `StatementReaderTests`,
  `LinqToSql` `QueryComparatorTests` / `QueryValidatorTests`,
  `Markdown.Tests` `ExpressionGeneratorTests` /
  `QueryBreakdownGeneratorTests`, and `JsonTokenReaderTests`.

- **CS8604 (8)**: `merged[someKey]` access inside `Assert.Multiple(() =>
  { ... })` lambdas where `someKey` is `string?` from `FirstOrDefault`.
  The preceding `Assert.That(someKey, Is.Not.Null)` does not propagate
  null-narrowing into the lambda scope, so add `!` to the dictionary
  index. (Tests fail loud with a meaningful message if the key really
  is null, so this is safe.)

- **NUnit2045 (1)**: wrap a four-assert block in
  `JsonTokenReaderTests.cs:65-68` in `Assert.Multiple`. Mirrors the
  surrounding two `Assert.Multiple` groups in that method.

All 1180 tests stay green.

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

tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownWithClauseTests.cs

@@ -110,7 +110,7 @@ public class LinqQueryBreakdownWithClauseTests
         Assert.Multiple(() =>
         {
             Assert.That(valueKey, Is.Not.Null, "Should have a Value parameter");
-            Assert.That(merged[valueKey], Is.EqualTo("main_value"), "Main query parameter should take precedence");
+            Assert.That(merged[valueKey!], Is.EqualTo("main_value"), "Main query parameter should take precedence");
         });
     }
 

tests/Strata.SqlTools.LinqToSql.Tests/QueryComparatorTests.cs

@@ -236,7 +236,7 @@ public class QueryComparatorTests
         var comparator = QueryComparator.Compare(query1, query2);
 
         // Assert
-        Assert.That(comparator.Differences.Count, Is.GreaterThan(2));
+        Assert.That(comparator.Differences, Has.Count.GreaterThan(2));
         Assert.That(comparator.Differences, Does.Contain("SELECT clauses differ"));
         Assert.That(comparator.Differences, Does.Contain("FROM clauses differ"));
     }

tests/Strata.SqlTools.LinqToSql.Tests/QueryValidatorTests.cs

@@ -495,7 +495,7 @@ public class QueryValidatorTests
         Assert.Multiple(() =>
         {
             // Assert
-            Assert.That(validator.Issues.Count, Is.GreaterThan(1));
+            Assert.That(validator.Issues, Has.Count.GreaterThan(1));
             Assert.That(validator.HasWarnings, Is.True);
         });
     }

tests/Strata.SqlTools.Markdown.Tests/Expressions/ExpressionGeneratorTests.cs

@@ -114,7 +114,7 @@ public class ExpressionGeneratorTests
         Assert.That(result, Does.Contain("## Mermaid Diagram"));
         Assert.That(result, Does.Contain("## Mathematical Expression"));
         Assert.That(result, Does.Contain("Arithmetic"));
-        Assert.That(result.Length, Is.GreaterThan(200));
+        Assert.That(result, Has.Length.GreaterThan(200));
     }
 
     [Test]

tests/Strata.SqlTools.Markdown.Tests/SqlServer/QueryBreakdownGeneratorTests.cs

@@ -84,7 +84,7 @@ public class QueryBreakdownGeneratorTests
         Assert.That(result, Is.Not.Null);
         Assert.That(result, Does.Contain("mermaid"));
         Assert.That(result, Does.Contain("SELECT"));
-        Assert.That(result.Length, Is.GreaterThan(100));
+        Assert.That(result, Has.Length.GreaterThan(100));
     }
 
     [Test]

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

@@ -162,7 +162,7 @@ public class QueryBreakdownTests
         queryBreakdown.AddParameter("param3", new DateTime(2025, 1, 1));
 
         // Assert
-        Assert.That(queryBreakdown.Parameters.Count, Is.GreaterThanOrEqualTo(3));
+        Assert.That(queryBreakdown.Parameters, Has.Count.GreaterThanOrEqualTo(3));
         Assert.Multiple(() =>
         {
             Assert.That(queryBreakdown.Parameters.ContainsKey("param1"), Is.True);
@@ -248,7 +248,7 @@ public class QueryBreakdownTests
         var queryBreakdown = QueryBreakdown.Parse(sql);
 
         // Assert
-        Assert.That(queryBreakdown.Parameters.Count, Is.GreaterThanOrEqualTo(0));
+        Assert.That(queryBreakdown.Parameters, Has.Count.GreaterThanOrEqualTo(0));
     }
 
     [Test]
@@ -488,7 +488,7 @@ public class QueryBreakdownTests
 
         // Assert
         // PostgreSQL stores parameters with positional and name-based formats
-        Assert.That(merged.Count, Is.GreaterThanOrEqualTo(2));
+        Assert.That(merged, Has.Count.GreaterThanOrEqualTo(2));
         var keys = merged.Keys.ToList();
         Assert.Multiple(() =>
         {
@@ -568,7 +568,7 @@ public class QueryBreakdownTests
         Assert.Multiple(() =>
         {
             Assert.That(userIdKey, Is.Not.Null);
-            Assert.That(merged[userIdKey], Is.EqualTo(123)); // Main query value, not CTE value
+            Assert.That(merged[userIdKey!], Is.EqualTo(123)); // Main query value, not CTE value
         });
     }
 
@@ -623,13 +623,13 @@ public class QueryBreakdownTests
         Assert.Multiple(() =>
         {
             Assert.That(dateKey, Is.Not.Null);
-            Assert.That(merged[dateKey], Is.TypeOf<DateTime>());
+            Assert.That(merged[dateKey!], Is.TypeOf<DateTime>());
 
             Assert.That(boolKey, Is.Not.Null);
-            Assert.That(merged[boolKey], Is.TypeOf<bool>());
+            Assert.That(merged[boolKey!], Is.TypeOf<bool>());
 
             Assert.That(doubleKey, Is.Not.Null);
-            Assert.That(merged[doubleKey], Is.TypeOf<double>());
+            Assert.That(merged[doubleKey!], Is.TypeOf<double>());
         });
     }
 

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

@@ -185,7 +185,7 @@ public class RecursiveCTETests
         Assert.Multiple(() =>
         {
             Assert.That(statusKey, Is.Not.Null);
-            Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence");
+            Assert.That(merged[statusKey!], Is.EqualTo("active"), "Main query parameter should take precedence");
         });
     }
 

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

@@ -121,7 +121,7 @@ public class StatementReaderTests
 
         // Assert
         var identifierTokens = tokens.Where(t => t.Type == TokenType.ColumnIdentifier).ToList();
-        Assert.That(identifierTokens.Count, Is.GreaterThanOrEqualTo(2));
+        Assert.That(identifierTokens, Has.Count.GreaterThanOrEqualTo(2));
     }
 
     [Test]
@@ -210,7 +210,7 @@ public class StatementReaderTests
 
         // Assert
         var stringTokens = tokens.Where(t => t.Type == TokenType.String).ToList();
-        Assert.That(stringTokens.Count, Is.GreaterThanOrEqualTo(2));
+        Assert.That(stringTokens, Has.Count.GreaterThanOrEqualTo(2));
     }
 
     [Test]

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

@@ -383,7 +383,7 @@ public class QueryBreakdownTests
 
         // Assert
         // Snowflake stores parameters in both @ and : formats, so count is doubled
-        Assert.That(merged.Count, Is.GreaterThanOrEqualTo(2));
+        Assert.That(merged, Has.Count.GreaterThanOrEqualTo(2));
         Assert.Multiple(() =>
         {
             Assert.That(merged.ContainsKey("@UserId") || merged.ContainsKey(":UserId"), Is.True);
@@ -1041,7 +1041,7 @@ public class QueryBreakdownTests
         var queryBreakdown = QueryBreakdown.Parse(sql, false);
 
         // Assert
-        Assert.That(queryBreakdown.Parameters.Count, Is.GreaterThanOrEqualTo(5));
+        Assert.That(queryBreakdown.Parameters, Has.Count.GreaterThanOrEqualTo(5));
         Assert.That(queryBreakdown.Parameters, Does.ContainKey(":userId"));
         Assert.That(queryBreakdown.Parameters, Does.ContainKey(":startDate"));
         Assert.That(queryBreakdown.Parameters, Does.ContainKey(":endDate"));
@@ -1156,7 +1156,7 @@ public class QueryBreakdownTests
         // Assert
         Assert.That(sql, Does.Contain("CTE_0 AS ("));
         Assert.That(sql, Does.Contain("CTE_14 AS ("));
-        Assert.That(sql.Length, Is.GreaterThan(1000));
+        Assert.That(sql, Has.Length.GreaterThan(1000));
     }
 
     #endregion
@@ -1323,7 +1323,7 @@ public class QueryBreakdownTests
         Assert.Multiple(() =>
         {
             Assert.That(sql, Does.Contain("LIMIT 100"));
-            Assert.That(mainQueryBreakdown.Parameters.Count, Is.GreaterThanOrEqualTo(2));
+            Assert.That(mainQueryBreakdown.Parameters, Has.Count.GreaterThanOrEqualTo(2));
         });
     }
 
@@ -2069,7 +2069,7 @@ public class QueryBreakdownTests
         query.AddWhereClause("CREATED_DATE > :StartDate", "and", false);
 
         // Assert
-        Assert.That(query.Parameters.Count, Is.GreaterThanOrEqualTo(3));
+        Assert.That(query.Parameters, Has.Count.GreaterThanOrEqualTo(3));
         Assert.That(query.Parameters, Does.ContainKey(":UserId"));
         Assert.That(query.Parameters, Does.ContainKey(":Status"));
         Assert.That(query.Parameters, Does.ContainKey(":StartDate"));

tests/Strata.SqlTools.Snowflake.Tests/Snowflake/RecursiveCTETests.cs

@@ -185,7 +185,7 @@ public class RecursiveCTETests
         Assert.Multiple(() =>
         {
             Assert.That(statusKey, Is.Not.Null);
-            Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence");
+            Assert.That(merged[statusKey!], Is.EqualTo("active"), "Main query parameter should take precedence");
         });
     }
 

tests/Strata.SqlTools.SqlBreakdown.Tests/JsonTokenReaderTests.cs

@@ -32,7 +32,7 @@ public class JsonTokenReaderTests
         Assert.That(tokens, Is.Not.Empty);
 
         // Validate JSON starts with StartObject and ends with EndObject
-        Assert.That(tokens.Count, Is.GreaterThan(2));
+        Assert.That(tokens, Has.Count.GreaterThan(2));
         Assert.Multiple(() =>
         {
             Assert.That(tokens[0].Type, Is.EqualTo(JsonTokenType.StartObject));

tests/Strata.SqlTools.SqlServer.Tests/SqlServer/RecursiveCTETests.cs

@@ -184,7 +184,7 @@ public class RecursiveCTETests
         Assert.Multiple(() =>
         {
             Assert.That(statusKey, Is.Not.Null);
-            Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence");
+            Assert.That(merged[statusKey!], Is.EqualTo("active"), "Main query parameter should take precedence");
         });
     }