From 505ada50171912d1c7cf86242e14e3a00621440b Mon Sep 17 00:00:00 2001 From: Thom Lamb Date: Wed, 27 May 2026 11:58:00 -0500 Subject: [PATCH 1/5] chore(sonar): adopt Has.Count, Is.Empty, Does.Contain, char overloads in tests (NUnit2046, NUnit2011, CA1866) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - NUnit2046: `Assert.That(x.Count, Is.EqualTo(n))` → `Assert.That(x, Has.Count.EqualTo(n))` (or `Is.Empty` when n==0) - NUnit2011: `Assert.That(s.Contains(x))` → `Assert.That(s, Does.Contain(x))` for richer failure messages - CA1866: `.StartsWith("$"|"@"|":")` → `.StartsWith('$'|'@'|':')` char overload Driven by `dotnet format analyzers --diagnostics NUnit2046 NUnit2011 CA1866` for the cases the Roslyn fixer handles, plus a regex sweep for the remaining `Count == n` (n>0) cases which the fixer doesn't address. CA1866 had no associated code fix and was edited by hand (3 sites in 2 files). All tests green (1180 passing). Co-Authored-By: Claude Opus 4.7 (1M context) --- .../LinqQueryBreakdownTests.cs | 2 +- .../QueryCollectionAnalyzerTests.cs | 10 +++---- .../QueryValidatorTests.cs | 6 ++-- .../QueryBreakdownCollectionTests.cs | 6 ++-- .../PostgreSql/RecursiveCTETests.cs | 6 ++-- .../PostgreSql/StatementReaderTests.cs | 2 +- .../QueryBreakdownCollectionTests.cs | 20 ++++++------- .../Snowflake/QueryBreakdownTests.cs | 14 ++++----- .../Snowflake/RecursiveCTETests.cs | 6 ++-- .../Exceptions/ExceptionHandlingTests.cs | 2 +- .../QueryBreakdownExtensionsTests.cs | 10 +++---- .../SqlBreakdownCollectionCoreTests.cs | 26 ++++++++-------- .../SqlBreakdownCollectionCreateTests.cs | 4 +-- .../SqlBreakdownCollectionDeleteTests.cs | 4 +-- .../SqlBreakdownCollectionDropTests.cs | 4 +-- .../SqlBreakdownCollectionInsertTests.cs | 6 ++-- .../SqlBreakdownCollectionMixedCrudTests.cs | 6 ++-- .../SqlBreakdownCollectionParameterTests.cs | 4 +-- .../SqlBreakdownCollectionSelectTests.cs | 4 +-- .../SqlBreakdownCollectionSeparatorTests.cs | 6 ++-- .../SqlBreakdownCollectionUpdateTests.cs | 4 +-- .../QueryBreakdownCollectionTests.cs | 30 +++++++++---------- .../SqlServer/QueryBreakdownTests.cs | 24 +++++++-------- .../SqlServer/RecursiveCTETests.cs | 4 +-- 24 files changed, 105 insertions(+), 105 deletions(-) diff --git a/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownTests.cs b/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownTests.cs index 3464611..8fbd9e0 100644 --- a/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownTests.cs +++ b/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownTests.cs @@ -692,7 +692,7 @@ public class GetQueryTests Assert.That(breakdown, Is.Not.Null); Assert.That(breakdown.ProcedureName.Clause, Is.EqualTo(procName)); Assert.That(breakdown.Parameters, Is.Not.Empty); - Assert.That(breakdown.Parameters.Count, Is.EqualTo(2)); + Assert.That(breakdown.Parameters, Has.Count.EqualTo(2)); } [Test] diff --git a/tests/Strata.SqlTools.LinqToSql.Tests/QueryCollectionAnalyzerTests.cs b/tests/Strata.SqlTools.LinqToSql.Tests/QueryCollectionAnalyzerTests.cs index df6528a..9932bdd 100644 --- a/tests/Strata.SqlTools.LinqToSql.Tests/QueryCollectionAnalyzerTests.cs +++ b/tests/Strata.SqlTools.LinqToSql.Tests/QueryCollectionAnalyzerTests.cs @@ -22,7 +22,7 @@ public class QueryCollectionAnalyzerTests // Assert Assert.That(stats.TotalQueries, Is.EqualTo(0)); Assert.That(stats.UniqueQueries, Is.EqualTo(0)); - Assert.That(stats.DuplicateQueries.Count, Is.EqualTo(0)); + Assert.That(stats.DuplicateQueries, Is.Empty); } [Test] @@ -46,7 +46,7 @@ public class QueryCollectionAnalyzerTests // Assert Assert.That(stats.TotalQueries, Is.EqualTo(1)); Assert.That(stats.UniqueQueries, Is.EqualTo(1)); - Assert.That(stats.DuplicateQueries.Count, Is.EqualTo(0)); + Assert.That(stats.DuplicateQueries, Is.Empty); } [Test] @@ -80,7 +80,7 @@ public class QueryCollectionAnalyzerTests // Assert Assert.That(stats.TotalQueries, Is.EqualTo(3)); Assert.That(stats.UniqueQueries, Is.EqualTo(1)); - Assert.That(stats.DuplicateQueries.Count, Is.EqualTo(2)); + Assert.That(stats.DuplicateQueries, Has.Count.EqualTo(2)); } #endregion @@ -345,7 +345,7 @@ public class QueryCollectionAnalyzerTests var duplicates = analyzer.FindDuplicates(); // Assert - Assert.That(duplicates.Count, Is.EqualTo(0)); + Assert.That(duplicates, Is.Empty); } [Test] @@ -365,7 +365,7 @@ public class QueryCollectionAnalyzerTests var duplicates = analyzer.FindDuplicates(); // Assert - Assert.That(duplicates.Count, Is.EqualTo(2)); + Assert.That(duplicates, Has.Count.EqualTo(2)); } #endregion diff --git a/tests/Strata.SqlTools.LinqToSql.Tests/QueryValidatorTests.cs b/tests/Strata.SqlTools.LinqToSql.Tests/QueryValidatorTests.cs index 52c8d50..4dcfbec 100644 --- a/tests/Strata.SqlTools.LinqToSql.Tests/QueryValidatorTests.cs +++ b/tests/Strata.SqlTools.LinqToSql.Tests/QueryValidatorTests.cs @@ -348,7 +348,7 @@ public class QueryValidatorTests "This is a custom issue"); // Assert - Assert.That(validator.Issues.Count, Is.EqualTo(1)); + Assert.That(validator.Issues, Has.Count.EqualTo(1)); Assert.That(validator.Issues[0].Code, Is.EqualTo("CUSTOM_001")); Assert.That(validator.HasErrors, Is.True); } @@ -367,7 +367,7 @@ public class QueryValidatorTests // Assert Assert.That(result, Is.SameAs(validator)); - Assert.That(validator.Issues.Count, Is.EqualTo(3)); + Assert.That(validator.Issues, Has.Count.EqualTo(3)); } #endregion @@ -386,7 +386,7 @@ public class QueryValidatorTests validator.Clear(); // Assert - Assert.That(validator.Issues.Count, Is.EqualTo(0)); + Assert.That(validator.Issues, Is.Empty); } [Test] diff --git a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownCollectionTests.cs b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownCollectionTests.cs index 9bf2b2b..28865e1 100644 --- a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownCollectionTests.cs +++ b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownCollectionTests.cs @@ -22,7 +22,7 @@ public class QueryBreakdownCollectionTests var collection = new QueryBreakdownCollection(); // Assert - Assert.That(collection.Count, Is.EqualTo(0)); + Assert.That(collection, Is.Empty); } #endregion @@ -56,7 +56,7 @@ public class QueryBreakdownCollectionTests _collection.Add(query3); // Assert - Assert.That(_collection.Count, Is.EqualTo(3)); + Assert.That(_collection, Has.Count.EqualTo(3)); } #endregion @@ -285,7 +285,7 @@ public class QueryBreakdownCollectionTests // Assert Assert.That(sql, Does.Contain("SELECT")); Assert.That(sql, Does.Contain(";")); - Assert.That(_collection.Count, Is.EqualTo(3)); + Assert.That(_collection, Has.Count.EqualTo(3)); } #endregion diff --git a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/RecursiveCTETests.cs b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/RecursiveCTETests.cs index eddafdf..291b2e6 100644 --- a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/RecursiveCTETests.cs +++ b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/RecursiveCTETests.cs @@ -175,7 +175,7 @@ public class RecursiveCTETests // Assert // PostgreSQL stores parameters with positional syntax - var statusKey = merged.Keys.FirstOrDefault(k => k.Contains("Status") && !k.StartsWith("$")); + var statusKey = merged.Keys.FirstOrDefault(k => k.Contains("Status") && !k.StartsWith('$')); Assert.That(statusKey, Is.Not.Null); Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence"); } @@ -247,8 +247,8 @@ public class RecursiveCTETests // Assert Assert.That(sql, Contains.Substring("WITH RECURSIVE")); - Assert.That(sql.Contains("base AS"), "Non-recursive CTE should be included"); - Assert.That(sql.Contains("tree_hierarchy AS"), "Recursive CTE should be included"); + Assert.That(sql, Does.Contain("base AS"), "Non-recursive CTE should be included"); + Assert.That(sql, Does.Contain("tree_hierarchy AS"), "Recursive CTE should be included"); } [Test] diff --git a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/StatementReaderTests.cs b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/StatementReaderTests.cs index d3ccaf6..318c9ac 100644 --- a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/StatementReaderTests.cs +++ b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/StatementReaderTests.cs @@ -88,7 +88,7 @@ public class StatementReaderTests // Assert Assert.That(tokens.Count, Is.GreaterThan(0)); var paramTokens = tokens.Where(t => t.Type == TokenType.Parameter).ToList(); - Assert.That(paramTokens.Count, Is.EqualTo(2)); + Assert.That(paramTokens, Has.Count.EqualTo(2)); Assert.That(paramTokens[0].Value, Is.EqualTo("$1")); Assert.That(paramTokens[1].Value, Is.EqualTo("$2")); } diff --git a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownCollectionTests.cs b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownCollectionTests.cs index 93723c6..b929e34 100644 --- a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownCollectionTests.cs +++ b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownCollectionTests.cs @@ -17,7 +17,7 @@ public class QueryBreakdownCollectionTests public void Constructor_Empty_CreatesEmptyCollection() { // Act & Assert - Assert.That(_collection.Count, Is.EqualTo(0)); + Assert.That(_collection, Is.Empty); Assert.That(_collection.QueryBreakdowns, Is.Empty); } @@ -35,8 +35,8 @@ public class QueryBreakdownCollectionTests var collection = new QueryBreakdownCollection(queries); // Assert - Assert.That(collection.Count, Is.EqualTo(2)); - Assert.That(collection.QueryBreakdowns.Count, Is.EqualTo(2)); + Assert.That(collection, Has.Count.EqualTo(2)); + Assert.That(collection.QueryBreakdowns, Has.Count.EqualTo(2)); } [Test] @@ -49,7 +49,7 @@ public class QueryBreakdownCollectionTests _collection.Add(query); // Assert - Assert.That(_collection.Count, Is.EqualTo(1)); + Assert.That(_collection, Has.Count.EqualTo(1)); Assert.That(_collection.QueryBreakdowns[0], Is.EqualTo(query)); } @@ -103,7 +103,7 @@ public class QueryBreakdownCollectionTests var results = _collection.WhereUseStageReference().ToList(); // Assert - Assert.That(results.Count, Is.EqualTo(1)); + Assert.That(results, Has.Count.EqualTo(1)); } [Test] @@ -121,7 +121,7 @@ public class QueryBreakdownCollectionTests // Assert // Only the stage reference query should be returned, not the parameter query - Assert.That(results.Count, Is.EqualTo(1)); + Assert.That(results, Has.Count.EqualTo(1)); Assert.That(results[0], Is.EqualTo(queryWithStage)); } @@ -139,7 +139,7 @@ public class QueryBreakdownCollectionTests var results = _collection.WhereUseSemiStructuredData().ToList(); // Assert - Assert.That(results.Count, Is.EqualTo(1)); + Assert.That(results, Has.Count.EqualTo(1)); } [Test] @@ -168,7 +168,7 @@ public class QueryBreakdownCollectionTests var tables = _collection.GetUniqueTableReferences().ToList(); // Assert - Assert.That(tables.Count, Is.EqualTo(2)); + Assert.That(tables, Has.Count.EqualTo(2)); Assert.That(tables, Does.Contain("Users")); Assert.That(tables, Does.Contain("Orders")); } @@ -187,7 +187,7 @@ public class QueryBreakdownCollectionTests var summaries = _collection.GetQuerySummaries().ToList(); // Assert - Assert.That(summaries.Count, Is.EqualTo(2)); + Assert.That(summaries, Has.Count.EqualTo(2)); Assert.That(summaries[0].UsesSemiStructuredData, Is.True); Assert.That(summaries[1].UsesStageReference, Is.True); } @@ -273,6 +273,6 @@ public class QueryBreakdownCollectionTests _collection.Clear(); // Assert - Assert.That(_collection.Count, Is.EqualTo(0)); + Assert.That(_collection, Is.Empty); } } diff --git a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownTests.cs b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownTests.cs index 58848b7..849f135 100644 --- a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownTests.cs +++ b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownTests.cs @@ -171,7 +171,7 @@ public class QueryBreakdownTests mainQueryBreakdown.AddWithClause("PRODUCT_ORDERS", cteSql); // Assert - Assert.That(mainQueryBreakdown.WithClauses.Count, Is.EqualTo(1)); + Assert.That(mainQueryBreakdown.WithClauses, Has.Count.EqualTo(1)); Assert.That(mainQueryBreakdown.WithClauses[0].TableName, Is.EqualTo("PRODUCT_ORDERS")); } @@ -186,7 +186,7 @@ public class QueryBreakdownTests mainQueryBreakdown.AddWithClause("ProductOrders", cteSql, isMicrosoftSql: true); // Assert - Assert.That(mainQueryBreakdown.WithClauses.Count, Is.EqualTo(1)); + Assert.That(mainQueryBreakdown.WithClauses, Has.Count.EqualTo(1)); Assert.That(mainQueryBreakdown.WithClauses[0].TableName, Is.EqualTo("ProductOrders")); } @@ -202,7 +202,7 @@ public class QueryBreakdownTests mainQueryBreakdown.AddWithClause("PRODUCT_ORDERS", cteQuery); // Assert - Assert.That(mainQueryBreakdown.WithClauses.Count, Is.EqualTo(1)); + Assert.That(mainQueryBreakdown.WithClauses, Has.Count.EqualTo(1)); Assert.That(mainQueryBreakdown.WithClauses[0].Query, Is.EqualTo(cteQuery)); } @@ -336,7 +336,7 @@ public class QueryBreakdownTests // Assert - Now using WITH clause Assert.That(query.IsUsingWithClause, Is.True); - Assert.That(query.WithClauses.Count, Is.EqualTo(1)); + Assert.That(query.WithClauses, Has.Count.EqualTo(1)); } #endregion @@ -688,7 +688,7 @@ public class QueryBreakdownTests queryBreakdown.AddWithClause("ORDER_CTE", cte); // Assert - Assert.That(queryBreakdown.WithClauses.Count, Is.EqualTo(1)); + Assert.That(queryBreakdown.WithClauses, Has.Count.EqualTo(1)); Assert.That(queryBreakdown.IsUsingWithClause, Is.True); } @@ -763,7 +763,7 @@ public class QueryBreakdownTests // Assert Assert.That(sql, Does.Contain("WITH")); Assert.That(sql, Does.Contain("MIDDLE_CTE AS (")); - Assert.That(mainQueryBreakdown.WithClauses.Count, Is.EqualTo(1)); + Assert.That(mainQueryBreakdown.WithClauses, Has.Count.EqualTo(1)); } [Test] @@ -1511,7 +1511,7 @@ public class QueryBreakdownTests var snowflakeSql = result.GetSql(); // Assert - Assert.That(result.WithClauses.Count, Is.EqualTo(1)); + Assert.That(result.WithClauses, Has.Count.EqualTo(1)); Assert.That(snowflakeSql, Does.Contain("WITH")); Assert.That(snowflakeSql, Does.Contain("ProductSummary AS (")); } diff --git a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/RecursiveCTETests.cs b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/RecursiveCTETests.cs index ca46e4d..54a8830 100644 --- a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/RecursiveCTETests.cs +++ b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/RecursiveCTETests.cs @@ -175,7 +175,7 @@ public class RecursiveCTETests // Assert // Snowflake stores parameters with both @ and : formats - var statusKey = merged.Keys.FirstOrDefault(k => k.Contains("Status") && (k.StartsWith("@") || k.StartsWith(":"))); + var statusKey = merged.Keys.FirstOrDefault(k => k.Contains("Status") && (k.StartsWith('@') || k.StartsWith(':'))); Assert.That(statusKey, Is.Not.Null); Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence"); } @@ -247,8 +247,8 @@ public class RecursiveCTETests // Assert Assert.That(sql, Contains.Substring("WITH RECURSIVE")); - Assert.That(sql.Contains("base AS"), "Non-recursive CTE should be included"); - Assert.That(sql.Contains("tree_hierarchy AS"), "Recursive CTE should be included"); + Assert.That(sql, Does.Contain("base AS"), "Non-recursive CTE should be included"); + Assert.That(sql, Does.Contain("tree_hierarchy AS"), "Recursive CTE should be included"); } [Test] diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/Exceptions/ExceptionHandlingTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/Exceptions/ExceptionHandlingTests.cs index 770d98d..11b1661 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/Exceptions/ExceptionHandlingTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/Exceptions/ExceptionHandlingTests.cs @@ -389,7 +389,7 @@ public class ExceptionHandlingTests query.AddWithClause("active_users", cteQuery); // Assert - Assert.That(query.WithClauses.Count, Is.EqualTo(1)); + Assert.That(query.WithClauses, Has.Count.EqualTo(1)); Assert.That(query.WithClauses[0].TableName, Is.EqualTo("active_users")); } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/Extensions/QueryBreakdownExtensionsTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/Extensions/QueryBreakdownExtensionsTests.cs index 8b4185e..3c28460 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/Extensions/QueryBreakdownExtensionsTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/Extensions/QueryBreakdownExtensionsTests.cs @@ -188,7 +188,7 @@ public class QueryBreakdownExtensionsTests // Assert Assert.That(query.IsUsingWithClause, Is.True); - Assert.That(query.WithClauses.Count, Is.EqualTo(1)); + Assert.That(query.WithClauses, Has.Count.EqualTo(1)); Assert.That(query.WithClauses[0].TableName, Is.EqualTo("active_users")); Assert.That(query.SelectClause.Clause, Is.EqualTo("*")); Assert.That(query.FromClause.Clause, Is.EqualTo("active_users")); @@ -238,7 +238,7 @@ public class QueryBreakdownExtensionsTests // Assert Assert.That(query.IsUsingWithClause, Is.True); - Assert.That(query.WithClauses.Count, Is.EqualTo(2)); + Assert.That(query.WithClauses, Has.Count.EqualTo(2)); Assert.That(query.WithClauses[0].TableName, Is.EqualTo("active_users")); Assert.That(query.WithClauses[1].TableName, Is.EqualTo("recent_orders")); } @@ -261,7 +261,7 @@ public class QueryBreakdownExtensionsTests // Assert Assert.That(query.IsUsingWithClause, Is.True); - Assert.That(query.WithClauses.Count, Is.EqualTo(1)); + Assert.That(query.WithClauses, Has.Count.EqualTo(1)); Assert.That(sql, Does.Contain("active_users (id, name, email)")); } @@ -282,7 +282,7 @@ public class QueryBreakdownExtensionsTests // Assert Assert.That(query.IsUsingWithClause, Is.True); - Assert.That(query.WithClauses.Count, Is.EqualTo(1)); + Assert.That(query.WithClauses, Has.Count.EqualTo(1)); Assert.That(query.WithClauses[0].TableName, Is.EqualTo("active_users")); } @@ -356,7 +356,7 @@ public class QueryBreakdownExtensionsTests var sql = query.GetSql(); // Assert - Assert.That(query.WithClauses.Count, Is.EqualTo(2)); + Assert.That(query.WithClauses, Has.Count.EqualTo(2)); Assert.That(sql, Does.Contain("active_users AS")); Assert.That(sql, Does.Contain("user_orders AS")); Assert.That(sql, Does.Contain("customer_tier")); diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCoreTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCoreTests.cs index 3f4de58..0f5b134 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCoreTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCoreTests.cs @@ -16,7 +16,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase var collection = new SqlBreakdownCollection(); // Assert - Assert.That(collection.Count, Is.EqualTo(0)); + Assert.That(collection, Is.Empty); Assert.That(collection.IsEmpty, Is.True); Assert.That(collection.Breakdowns, Is.Empty); Assert.That(collection.RawStatements, Is.Empty); @@ -36,7 +36,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase var collection = new SqlBreakdownCollection(mockBreakdowns); // Assert - Assert.That(collection.Count, Is.EqualTo(2)); + Assert.That(collection, Has.Count.EqualTo(2)); Assert.That(collection.IsEmpty, Is.False); } @@ -51,7 +51,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase collection.Add(breakdown); // Assert - Assert.That(collection.Count, Is.EqualTo(1)); + Assert.That(collection, Has.Count.EqualTo(1)); Assert.That(collection.GetAt(0), Is.EqualTo(breakdown)); } @@ -81,7 +81,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase collection.AddRange(breakdowns); // Assert - Assert.That(collection.Count, Is.EqualTo(3)); + Assert.That(collection, Has.Count.EqualTo(3)); } [Test] @@ -106,7 +106,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase // Assert Assert.That(result, Is.True); - Assert.That(collection.Count, Is.EqualTo(0)); + Assert.That(collection, Is.Empty); } [Test] @@ -121,7 +121,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase // Assert Assert.That(result, Is.False); - Assert.That(collection.Count, Is.EqualTo(1)); + Assert.That(collection, Has.Count.EqualTo(1)); } [Test] @@ -138,7 +138,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase collection.Clear(); // Assert - Assert.That(collection.Count, Is.EqualTo(0)); + Assert.That(collection, Is.Empty); Assert.That(collection.IsEmpty, Is.True); } @@ -159,7 +159,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.RawStatements.Count, Is.EqualTo(3)); + Assert.That(collection.RawStatements, Has.Count.EqualTo(3)); Assert.That(collection.RawStatements[0], Does.Contain("Table1")); Assert.That(collection.RawStatements[1], Does.Contain("Table2")); Assert.That(collection.RawStatements[2], Does.Contain("Table3")); @@ -182,7 +182,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.RawStatements.Count, Is.EqualTo(3)); + Assert.That(collection.RawStatements, Has.Count.EqualTo(3)); } [Test] @@ -202,7 +202,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.RawStatements.Count, Is.EqualTo(3)); + Assert.That(collection.RawStatements, Has.Count.EqualTo(3)); } [Test] @@ -222,7 +222,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.RawStatements.Count, Is.EqualTo(2)); + Assert.That(collection.RawStatements, Has.Count.EqualTo(2)); Assert.That(collection.RawStatements[0], Does.Contain("Table1")); Assert.That(collection.RawStatements[1], Does.Contain("Table2")); } @@ -338,7 +338,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase var filtered = collection.Where(b => b.ToString()!.Contains("Table2")).ToList(); // Assert - Assert.That(filtered.Count, Is.EqualTo(1)); + Assert.That(filtered, Has.Count.EqualTo(1)); Assert.That(filtered[0].ToString()!, Does.Contain("Table2")); } @@ -357,7 +357,7 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase var projected = collection.Select(b => b.ToString()!.Length).ToList(); // Assert - Assert.That(projected.Count, Is.EqualTo(2)); + Assert.That(projected, Has.Count.EqualTo(2)); Assert.That(projected[0], Is.GreaterThan(0)); } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCreateTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCreateTests.cs index a5bf839..4c904fd 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCreateTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCreateTests.cs @@ -31,7 +31,7 @@ public class SqlBreakdownCollectionCreateTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.EqualTo(2)); + Assert.That(collection, Has.Count.EqualTo(2)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE TABLE Users")); Assert.That(collection.GetRawStatementAt(1), Does.Contain("CREATE TABLE Orders")); } @@ -51,7 +51,7 @@ public class SqlBreakdownCollectionCreateTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.EqualTo(2)); + Assert.That(collection, Has.Count.EqualTo(2)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE INDEX")); Assert.That(collection.GetRawStatementAt(1), Does.Contain("UNIQUE")); } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDeleteTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDeleteTests.cs index f90d731..f33ff55 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDeleteTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDeleteTests.cs @@ -25,7 +25,7 @@ public class SqlBreakdownCollectionDeleteTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.EqualTo(3)); + Assert.That(collection, Has.Count.EqualTo(3)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("DELETE FROM Orders")); Assert.That(collection.GetRawStatementAt(1), Does.Contain("NOT IN")); Assert.That(collection.GetRawStatementAt(2), Does.Contain("DATEADD")); @@ -48,7 +48,7 @@ public class SqlBreakdownCollectionDeleteTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.EqualTo(2)); + Assert.That(collection, Has.Count.EqualTo(2)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("EXISTS")); } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDropTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDropTests.cs index 9b5a7e6..70d81d7 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDropTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDropTests.cs @@ -25,7 +25,7 @@ public class SqlBreakdownCollectionDropTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.EqualTo(3)); + Assert.That(collection, Has.Count.EqualTo(3)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("DROP TABLE")); Assert.That(collection.GetRawStatementAt(1), Does.Contain("DROP TABLE")); } @@ -47,7 +47,7 @@ public class SqlBreakdownCollectionDropTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.EqualTo(3)); + Assert.That(collection, Has.Count.EqualTo(3)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("DROP INDEX")); Assert.That(collection.GetRawStatementAt(1), Does.Contain("PROCEDURE")); Assert.That(collection.GetRawStatementAt(2), Does.Contain("VIEW")); diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionInsertTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionInsertTests.cs index 9933f14..8dde3fd 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionInsertTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionInsertTests.cs @@ -25,7 +25,7 @@ public class SqlBreakdownCollectionInsertTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.EqualTo(3)); + Assert.That(collection, Has.Count.EqualTo(3)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("INSERT INTO Users")); Assert.That(collection.GetRawStatementAt(1), Does.Contain("Jane Smith")); Assert.That(collection.GetRawStatementAt(2), Does.Contain("Bob Johnson")); @@ -48,7 +48,7 @@ public class SqlBreakdownCollectionInsertTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.EqualTo(2)); + Assert.That(collection, Has.Count.EqualTo(2)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("INSERT INTO UsersArchive")); Assert.That(collection.GetRawStatementAt(0), Does.Contain("SELECT")); } @@ -70,7 +70,7 @@ public class SqlBreakdownCollectionInsertTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.EqualTo(2)); + Assert.That(collection, Has.Count.EqualTo(2)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("BULK INSERT")); } } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionMixedCrudTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionMixedCrudTests.cs index b647d7c..c1577bc 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionMixedCrudTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionMixedCrudTests.cs @@ -37,7 +37,7 @@ public class SqlBreakdownCollectionMixedCrudTests : SqlBreakdownCollectionTestBa collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.EqualTo(7)); + Assert.That(collection, Has.Count.EqualTo(7)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE TABLE")); Assert.That(collection.GetRawStatementAt(1), Does.Contain("INSERT")); Assert.That(collection.GetRawStatementAt(3), Does.Contain("SELECT")); @@ -81,8 +81,8 @@ public class SqlBreakdownCollectionMixedCrudTests : SqlBreakdownCollectionTestBa collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.EqualTo(5)); - Assert.That(collection.RawStatements.Count, Is.EqualTo(5)); + Assert.That(collection, Has.Count.EqualTo(5)); + Assert.That(collection.RawStatements, Has.Count.EqualTo(5)); foreach (var statement in collection.RawStatements) { Assert.That(statement, Is.Not.Empty); diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionParameterTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionParameterTests.cs index 27c9484..7992366 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionParameterTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionParameterTests.cs @@ -23,7 +23,7 @@ public class SqlBreakdownCollectionParameterTests : SqlBreakdownCollectionTestBa collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.EqualTo(2)); + Assert.That(collection, Has.Count.EqualTo(2)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("@UserId")); Assert.That(collection.GetRawStatementAt(0), Does.Contain("@UserEmail")); } @@ -43,7 +43,7 @@ public class SqlBreakdownCollectionParameterTests : SqlBreakdownCollectionTestBa collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.EqualTo(2)); + Assert.That(collection, Has.Count.EqualTo(2)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("@Name")); Assert.That(collection.GetRawStatementAt(1), Does.Contain("@Status")); } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSelectTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSelectTests.cs index 461ef35..e198fa7 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSelectTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSelectTests.cs @@ -29,7 +29,7 @@ public class SqlBreakdownCollectionSelectTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.EqualTo(2)); + Assert.That(collection, Has.Count.EqualTo(2)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("LEFT JOIN")); Assert.That(collection.GetRawStatementAt(0), Does.Contain("GROUP BY")); Assert.That(collection.GetRawStatementAt(1), Does.Contain("BETWEEN")); @@ -79,7 +79,7 @@ public class SqlBreakdownCollectionSelectTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.EqualTo(2)); + Assert.That(collection, Has.Count.EqualTo(2)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("JOIN")); Assert.That(collection.GetRawStatementAt(1), Does.Contain("IN")); } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSeparatorTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSeparatorTests.cs index 7f7b912..80bfb80 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSeparatorTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSeparatorTests.cs @@ -25,7 +25,7 @@ public class SqlBreakdownCollectionSeparatorTests : SqlBreakdownCollectionTestBa collection.ParseBatch(batchSql, ";"); // Assert - Assert.That(collection.Count, Is.EqualTo(3)); + Assert.That(collection, Has.Count.EqualTo(3)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("Users")); Assert.That(collection.GetRawStatementAt(1), Does.Contain("Orders")); Assert.That(collection.GetRawStatementAt(2), Does.Contain("Products")); @@ -48,7 +48,7 @@ public class SqlBreakdownCollectionSeparatorTests : SqlBreakdownCollectionTestBa collection.ParseBatch(batchSql, "~~~"); // Assert - Assert.That(collection.Count, Is.EqualTo(3)); - Assert.That(collection.RawStatements.Count, Is.EqualTo(3)); + Assert.That(collection, Has.Count.EqualTo(3)); + Assert.That(collection.RawStatements, Has.Count.EqualTo(3)); } } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionUpdateTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionUpdateTests.cs index 1e79e2f..ba32431 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionUpdateTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionUpdateTests.cs @@ -25,7 +25,7 @@ public class SqlBreakdownCollectionUpdateTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.EqualTo(3)); + Assert.That(collection, Has.Count.EqualTo(3)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("UPDATE Users")); Assert.That(collection.GetRawStatementAt(1), Does.Contain("Status")); Assert.That(collection.GetRawStatementAt(2), Does.Contain("Price * 1.1")); @@ -52,7 +52,7 @@ public class SqlBreakdownCollectionUpdateTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.EqualTo(2)); + Assert.That(collection, Has.Count.EqualTo(2)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("UPDATE u")); Assert.That(collection.GetRawStatementAt(1), Does.Contain("Quantity - 1")); } diff --git a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownCollectionTests.cs b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownCollectionTests.cs index f6ee91d..420ef97 100644 --- a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownCollectionTests.cs +++ b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownCollectionTests.cs @@ -17,7 +17,7 @@ public class QueryBreakdownCollectionTests public void Constructor_Empty_CreatesEmptyCollection() { // Act & Assert - Assert.That(_collection.Count, Is.EqualTo(0)); + Assert.That(_collection, Is.Empty); Assert.That(_collection.QueryBreakdowns, Is.Empty); } @@ -35,8 +35,8 @@ public class QueryBreakdownCollectionTests var collection = new QueryBreakdownCollection(queries); // Assert - Assert.That(collection.Count, Is.EqualTo(2)); - Assert.That(collection.QueryBreakdowns.Count, Is.EqualTo(2)); + Assert.That(collection, Has.Count.EqualTo(2)); + Assert.That(collection.QueryBreakdowns, Has.Count.EqualTo(2)); } [Test] @@ -49,7 +49,7 @@ public class QueryBreakdownCollectionTests _collection.Add(query); // Assert - Assert.That(_collection.Count, Is.EqualTo(1)); + Assert.That(_collection, Has.Count.EqualTo(1)); Assert.That(_collection.QueryBreakdowns[0], Is.EqualTo(query)); } @@ -74,7 +74,7 @@ public class QueryBreakdownCollectionTests _collection.AddRange(queries); // Assert - Assert.That(_collection.Count, Is.EqualTo(2)); + Assert.That(_collection, Has.Count.EqualTo(2)); } [Test] @@ -89,7 +89,7 @@ public class QueryBreakdownCollectionTests // Assert Assert.That(removed, Is.True); - Assert.That(_collection.Count, Is.EqualTo(0)); + Assert.That(_collection, Is.Empty); } [Test] @@ -105,7 +105,7 @@ public class QueryBreakdownCollectionTests // Assert Assert.That(removed, Is.False); - Assert.That(_collection.Count, Is.EqualTo(1)); + Assert.That(_collection, Has.Count.EqualTo(1)); } [Test] @@ -119,7 +119,7 @@ public class QueryBreakdownCollectionTests _collection.Clear(); // Assert - Assert.That(_collection.Count, Is.EqualTo(0)); + Assert.That(_collection, Is.Empty); } [Test] @@ -164,7 +164,7 @@ public class QueryBreakdownCollectionTests var results = _collection.WhereSelectContains("Email").ToList(); // Assert - Assert.That(results.Count, Is.EqualTo(1)); + Assert.That(results, Has.Count.EqualTo(1)); Assert.That(results[0], Is.EqualTo(query1)); } @@ -179,7 +179,7 @@ public class QueryBreakdownCollectionTests var results = _collection.WhereSelectContains("email").ToList(); // Assert - Assert.That(results.Count, Is.EqualTo(1)); + Assert.That(results, Has.Count.EqualTo(1)); } [Test] @@ -195,7 +195,7 @@ public class QueryBreakdownCollectionTests var results = _collection.WhereTableContains("Users").ToList(); // Assert - Assert.That(results.Count, Is.EqualTo(1)); + Assert.That(results, Has.Count.EqualTo(1)); Assert.That(results[0], Is.EqualTo(query1)); } @@ -212,7 +212,7 @@ public class QueryBreakdownCollectionTests var results = _collection.WhereHaveWhereClause().ToList(); // Assert - Assert.That(results.Count, Is.EqualTo(1)); + Assert.That(results, Has.Count.EqualTo(1)); Assert.That(results[0], Is.EqualTo(query1)); } @@ -229,7 +229,7 @@ public class QueryBreakdownCollectionTests var results = _collection.WhereHaveNoWhereClause().ToList(); // Assert - Assert.That(results.Count, Is.EqualTo(1)); + Assert.That(results, Has.Count.EqualTo(1)); Assert.That(results[0], Is.EqualTo(query2)); } @@ -259,7 +259,7 @@ public class QueryBreakdownCollectionTests var tables = _collection.GetUniqueTableReferences().ToList(); // Assert - Assert.That(tables.Count, Is.EqualTo(2)); + Assert.That(tables, Has.Count.EqualTo(2)); Assert.That(tables, Does.Contain("Users")); Assert.That(tables, Does.Contain("Orders")); } @@ -275,7 +275,7 @@ public class QueryBreakdownCollectionTests var summaries = _collection.GetQuerySummaries().ToList(); // Assert - Assert.That(summaries.Count, Is.EqualTo(2)); + Assert.That(summaries, Has.Count.EqualTo(2)); Assert.That(summaries[0].HasSelectClause, Is.True); Assert.That(summaries[1].HasWhereClause, Is.True); } diff --git a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownTests.cs b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownTests.cs index 15a3ed8..423699e 100644 --- a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownTests.cs +++ b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownTests.cs @@ -26,7 +26,7 @@ public class QueryBreakdownTests Assert.That(query.SetupClauses, Is.Not.Null); Assert.That(query.FinishClauses, Is.Not.Null); Assert.That(query.WithClauses, Is.Not.Null); - Assert.That(query.WithClauses.Count, Is.EqualTo(0)); + Assert.That(query.WithClauses, Is.Empty); Assert.That(query.Parameters, Is.Not.Null); Assert.That(query.ParameterList, Is.Not.Null); } @@ -208,7 +208,7 @@ public class QueryBreakdownTests var merged = query.GetMergedParameters(); // Assert - Assert.That(merged.Count, Is.EqualTo(2)); + Assert.That(merged, Has.Count.EqualTo(2)); Assert.That(merged["@UserId"], Is.EqualTo(123)); Assert.That(merged["@ActiveStatus"], Is.EqualTo(true)); } @@ -228,7 +228,7 @@ public class QueryBreakdownTests var merged = mainQuery.GetMergedParameters(); // Assert - Assert.That(merged.Count, Is.EqualTo(2)); + Assert.That(merged, Has.Count.EqualTo(2)); Assert.That(merged["@MinDate"], Is.EqualTo(DateTime.Today.AddDays(-30))); Assert.That(merged["@Limit"], Is.EqualTo(100)); } @@ -252,7 +252,7 @@ public class QueryBreakdownTests var merged = mainQuery.GetMergedParameters(); // Assert - Assert.That(merged.Count, Is.EqualTo(3)); + Assert.That(merged, Has.Count.EqualTo(3)); Assert.That(merged["@Status1"], Is.EqualTo("active")); Assert.That(merged["@MinDate"], Is.EqualTo(DateTime.Today.AddDays(-30))); Assert.That(merged["@ResultLimit"], Is.EqualTo(50)); @@ -273,7 +273,7 @@ public class QueryBreakdownTests var merged = mainQuery.GetMergedParameters(); // Assert - Assert.That(merged.Count, Is.EqualTo(1)); + Assert.That(merged, Has.Count.EqualTo(1)); Assert.That(merged["@Limit"], Is.EqualTo(100)); // Main query value wins } @@ -296,7 +296,7 @@ public class QueryBreakdownTests var merged = mainQuery.GetMergedParameters(); // Assert - All parameters from all levels should be present - Assert.That(merged.Count, Is.EqualTo(3)); + Assert.That(merged, Has.Count.EqualTo(3)); Assert.That(merged["@InnerParam"], Is.EqualTo("inner_value")); Assert.That(merged["@MiddleParam"], Is.EqualTo("middle_value")); Assert.That(merged["@MainParam"], Is.EqualTo("main_value")); @@ -317,7 +317,7 @@ public class QueryBreakdownTests var merged = mainQuery.GetMergedParameters(); // Assert - Assert.That(merged.Count, Is.EqualTo(0)); + Assert.That(merged, Is.Empty); } [Test] @@ -464,7 +464,7 @@ public class QueryBreakdownTests query.AddWhereClause("CreatedDate > @StartDate", "and"); // Assert - Assert.That(query.Parameters.Count, Is.EqualTo(3)); + Assert.That(query.Parameters, Has.Count.EqualTo(3)); Assert.That(query.Parameters, Does.ContainKey("@UserId")); Assert.That(query.Parameters, Does.ContainKey("@Status")); Assert.That(query.Parameters, Does.ContainKey("@StartDate")); @@ -566,7 +566,7 @@ public class QueryBreakdownTests mainQuery.AddWithClause("ProductOrders", cteQuery); // Assert - Assert.That(mainQuery.WithClauses.Count, Is.EqualTo(1)); + Assert.That(mainQuery.WithClauses, Has.Count.EqualTo(1)); Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("ProductOrders")); Assert.That(mainQuery.WithClauses[0].Query, Is.EqualTo(cteQuery)); } @@ -586,7 +586,7 @@ public class QueryBreakdownTests mainQuery.AddWithClause("CTE3", cte3); // Assert - Assert.That(mainQuery.WithClauses.Count, Is.EqualTo(3)); + Assert.That(mainQuery.WithClauses, Has.Count.EqualTo(3)); Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("CTE1")); Assert.That(mainQuery.WithClauses[1].TableName, Is.EqualTo("CTE2")); Assert.That(mainQuery.WithClauses[2].TableName, Is.EqualTo("CTE3")); @@ -603,7 +603,7 @@ public class QueryBreakdownTests mainQuery.AddWithClause("ProductOrders", cteSql, isMicrosoftSql: true); // Assert - Assert.That(mainQuery.WithClauses.Count, Is.EqualTo(1)); + Assert.That(mainQuery.WithClauses, Has.Count.EqualTo(1)); Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("ProductOrders")); Assert.That(mainQuery.WithClauses[0].Query!.SelectClause.Clause, Does.Contain("ProductID")); Assert.That(mainQuery.WithClauses[0].Query!.GroupByClause.Clause, Does.Contain("ProductID")); @@ -769,7 +769,7 @@ public class QueryBreakdownTests // Assert - Now using WITH clause Assert.That(query.IsUsingWithClause, Is.True); - Assert.That(query.WithClauses.Count, Is.EqualTo(1)); + Assert.That(query.WithClauses, Has.Count.EqualTo(1)); } #endregion diff --git a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/RecursiveCTETests.cs b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/RecursiveCTETests.cs index ba0d20e..0ef4663 100644 --- a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/RecursiveCTETests.cs +++ b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/RecursiveCTETests.cs @@ -246,8 +246,8 @@ public class RecursiveCTETests // Assert Assert.That(sql, Contains.Substring("WITH RECURSIVE")); - Assert.That(sql.Contains("base AS"), "Non-recursive CTE should be included"); - Assert.That(sql.Contains("tree_hierarchy AS"), "Recursive CTE should be included"); + Assert.That(sql, Does.Contain("base AS"), "Non-recursive CTE should be included"); + Assert.That(sql, Does.Contain("tree_hierarchy AS"), "Recursive CTE should be included"); } [Test] -- 2.54.0 From 67512d23e18c22acbba84d1f43ebfaf085b54fdf Mon Sep 17 00:00:00 2001 From: Thom Lamb Date: Wed, 27 May 2026 11:59:47 -0500 Subject: [PATCH 2/5] chore(sonar): wrap independent assertions in Assert.Multiple (NUnit2045) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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) --- .../QueryBreakdownMapperTests.cs | 60 ++- .../QueryBreakdownRepositoryTests.cs | 16 +- .../LinqQueryBreakdownBuilderTests.cs | 46 +- .../LinqQueryBreakdownTests.cs | 183 +++++--- .../LinqQueryBreakdownWithClauseTests.cs | 48 ++- .../QueryCollectionAnalyzerTests.cs | 73 ++-- .../QueryValidatorTests.cs | 45 +- .../ReverseConverterTests.cs | 73 ++-- .../PostgreSql/CTEColumnListTests.cs | 16 +- .../QueryBreakdownCollectionTests.cs | 25 +- .../PostgreSql/QueryBreakdownTests.cs | 196 ++++++--- .../PostgreSql/RecursiveCTETests.cs | 27 +- .../PostgreSql/StatementReaderTests.cs | 40 +- .../MarkdownParserTests.cs | 205 ++++++--- .../RuleEngineTests.cs | 9 +- .../Snowflake/CTEColumnListTests.cs | 16 +- .../Snowflake/CommentTests.cs | 88 ++-- .../QueryBreakdownCollectionTests.cs | 16 +- .../Snowflake/QueryBreakdownTests.cs | 401 ++++++++++++------ .../Snowflake/RecursiveCTETests.cs | 27 +- .../StatementExpressionParserTests.cs | 51 ++- .../Snowflake/StatementReaderTests.cs | 120 +++--- .../Snowflake/WithClauseTests.cs | 169 +++++--- .../Exceptions/ExceptionHandlingTests.cs | 97 +++-- .../ExpressionTests/BooleanExpressionTests.cs | 7 +- .../GenericColumnExpressionTests.cs | 18 +- .../QueryBreakdownExtensionsTests.cs | 190 ++++++--- .../JsonTokenReaderTests.cs | 32 +- .../SqlBreakdownCollectionCoreTests.cs | 43 +- .../SqlBreakdownCollectionCreateTests.cs | 14 +- .../SqlBreakdownCollectionDeleteTests.cs | 9 +- .../SqlBreakdownCollectionDropTests.cs | 16 +- .../SqlBreakdownCollectionInsertTests.cs | 9 +- .../SqlBreakdownCollectionMixedCrudTests.cs | 15 +- .../SqlBreakdownCollectionParameterTests.cs | 7 +- .../SqlBreakdownCollectionSelectTests.cs | 14 +- .../SqlBreakdownCollectionSeparatorTests.cs | 9 +- .../SqlBreakdownCollectionUpdateTests.cs | 16 +- .../Performance/GetClausesCachingTests.cs | 27 +- .../SqlServer/CTEColumnListTests.cs | 18 +- .../SqlServer/CommentTests.cs | 81 ++-- .../QueryBreakdownCollectionTests.cs | 34 +- .../SqlServer/QueryBreakdownTests.cs | 320 +++++++++----- .../SqlServer/RecursiveCTETests.cs | 27 +- .../StatementExpressionParserTests.cs | 114 +++-- .../SqlServer/StatementReaderTests.cs | 9 +- .../SqlServer/WithClauseTests.cs | 169 +++++--- 47 files changed, 2132 insertions(+), 1113 deletions(-) diff --git a/tests/Strata.SqlTools.EFCore.Tests/QueryBreakdownMapperTests.cs b/tests/Strata.SqlTools.EFCore.Tests/QueryBreakdownMapperTests.cs index 1331e71..f89bfe9 100644 --- a/tests/Strata.SqlTools.EFCore.Tests/QueryBreakdownMapperTests.cs +++ b/tests/Strata.SqlTools.EFCore.Tests/QueryBreakdownMapperTests.cs @@ -27,9 +27,12 @@ public class QueryBreakdownMapperTests // Assert Assert.That(entity, Is.Not.Null); - Assert.That(entity.SelectClause, Is.EqualTo("ID, Name")); - Assert.That(entity.FromClause, Is.EqualTo("Users")); - Assert.That(entity.CreatedAt, Is.LessThanOrEqualTo(DateTime.UtcNow)); + Assert.Multiple(() => + { + Assert.That(entity.SelectClause, Is.EqualTo("ID, Name")); + Assert.That(entity.FromClause, Is.EqualTo("Users")); + Assert.That(entity.CreatedAt, Is.LessThanOrEqualTo(DateTime.UtcNow)); + }); } [Test] @@ -46,11 +49,14 @@ public class QueryBreakdownMapperTests // Act var entity = _mapper.MapToEntity(queryBreakdown); - // Assert - Assert.That(entity.SelectClause, Is.EqualTo("ID, Name")); - Assert.That(entity.FromClause, Is.EqualTo("Users")); - Assert.That(entity.WhereClause, Is.EqualTo("Active = 1")); - Assert.That(entity.OrderByClause, Is.EqualTo("Name ASC")); + Assert.Multiple(() => + { + // Assert + Assert.That(entity.SelectClause, Is.EqualTo("ID, Name")); + Assert.That(entity.FromClause, Is.EqualTo("Users")); + Assert.That(entity.WhereClause, Is.EqualTo("Active = 1")); + Assert.That(entity.OrderByClause, Is.EqualTo("Name ASC")); + }); } [Test] @@ -72,9 +78,12 @@ public class QueryBreakdownMapperTests // Assert Assert.That(queryBreakdown, Is.Not.Null); - Assert.That(queryBreakdown.SelectClause?.Clause, Is.EqualTo("ID, Name")); - Assert.That(queryBreakdown.FromClause?.Clause, Is.EqualTo("Users")); - Assert.That(queryBreakdown.WhereClause?.Clause, Is.EqualTo("Active = 1")); + Assert.Multiple(() => + { + Assert.That(queryBreakdown.SelectClause?.Clause, Is.EqualTo("ID, Name")); + Assert.That(queryBreakdown.FromClause?.Clause, Is.EqualTo("Users")); + Assert.That(queryBreakdown.WhereClause?.Clause, Is.EqualTo("Active = 1")); + }); } [Test] @@ -110,11 +119,14 @@ public class QueryBreakdownMapperTests var entity = _mapper.MapToEntity(originalQuery); var restoredQuery = _mapper.MapToDomainModel(entity); - // Assert - Assert.That(restoredQuery.SelectClause?.Clause, Is.EqualTo(originalQuery.SelectClause?.Clause)); - Assert.That(restoredQuery.FromClause?.Clause, Is.EqualTo(originalQuery.FromClause?.Clause)); - Assert.That(restoredQuery.WhereClause?.Clause, Is.EqualTo(originalQuery.WhereClause?.Clause)); - Assert.That(restoredQuery.OrderByClause?.Clause, Is.EqualTo(originalQuery.OrderByClause?.Clause)); + Assert.Multiple(() => + { + // Assert + Assert.That(restoredQuery.SelectClause?.Clause, Is.EqualTo(originalQuery.SelectClause?.Clause)); + Assert.That(restoredQuery.FromClause?.Clause, Is.EqualTo(originalQuery.FromClause?.Clause)); + Assert.That(restoredQuery.WhereClause?.Clause, Is.EqualTo(originalQuery.WhereClause?.Clause)); + Assert.That(restoredQuery.OrderByClause?.Clause, Is.EqualTo(originalQuery.OrderByClause?.Clause)); + }); } [Test] @@ -127,10 +139,16 @@ public class QueryBreakdownMapperTests // Act var (entity, parameters, withClauses) = _mapper.MapToEntityWithRelations(queryBreakdown); - // Assert - Assert.That(entity, Is.Not.Null); - Assert.That(parameters, Is.Not.Empty); - Assert.That(parameters.First().ParameterName, Is.EqualTo("UserId")); - Assert.That(withClauses, Is.Empty); + Assert.Multiple(() => + { + // Assert + Assert.That(entity, Is.Not.Null); + Assert.That(parameters, Is.Not.Empty); + }); + Assert.Multiple(() => + { + Assert.That(parameters.First().ParameterName, Is.EqualTo("UserId")); + Assert.That(withClauses, Is.Empty); + }); } } diff --git a/tests/Strata.SqlTools.EFCore.Tests/QueryBreakdownRepositoryTests.cs b/tests/Strata.SqlTools.EFCore.Tests/QueryBreakdownRepositoryTests.cs index eaad8d3..482c387 100644 --- a/tests/Strata.SqlTools.EFCore.Tests/QueryBreakdownRepositoryTests.cs +++ b/tests/Strata.SqlTools.EFCore.Tests/QueryBreakdownRepositoryTests.cs @@ -58,8 +58,11 @@ public class QueryBreakdownRepositoryTests // Assert Assert.That(retrieved, Is.Not.Null); - Assert.That(retrieved?.SelectClause?.Clause, Is.EqualTo("ID, Name")); - Assert.That(retrieved?.FromClause?.Clause, Is.EqualTo("Users")); + Assert.Multiple(() => + { + Assert.That(retrieved?.SelectClause?.Clause, Is.EqualTo("ID, Name")); + Assert.That(retrieved?.FromClause?.Clause, Is.EqualTo("Users")); + }); } [Test] @@ -117,9 +120,12 @@ public class QueryBreakdownRepositoryTests bool deleted = await _repository.DeleteAsync(id); var retrieved = await _repository.GetByIdAsync(id); - // Assert - Assert.That(deleted, Is.True); - Assert.That(retrieved, Is.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(deleted, Is.True); + Assert.That(retrieved, Is.Null); + }); } [Test] diff --git a/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownBuilderTests.cs b/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownBuilderTests.cs index ca4d15e..1b9aada 100644 --- a/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownBuilderTests.cs +++ b/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownBuilderTests.cs @@ -23,9 +23,12 @@ public class LinqQueryBreakdownBuilderTests // Assert Assert.That(breakdown, Is.Not.Null); - Assert.That(breakdown.SelectClause.Clause, Contains.Substring("Id")); - Assert.That(breakdown.FromClause.Clause, Is.EqualTo("Users")); - Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("Age > 18")); + Assert.Multiple(() => + { + Assert.That(breakdown.SelectClause.Clause, Contains.Substring("Id")); + Assert.That(breakdown.FromClause.Clause, Is.EqualTo("Users")); + Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("Age > 18")); + }); } [Test] @@ -375,13 +378,16 @@ public class LinqQueryBreakdownBuilderTests .OrderByDescending("AvgSalary") .Build(); - // Assert - Assert.That(breakdown.SelectClause.Clause, Contains.Substring("Department")); - Assert.That(breakdown.FromClause.Clause, Is.EqualTo("Employees")); - Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("IsActive = true")); - Assert.That(breakdown.GroupByClause.Clause, Is.EqualTo("Department, Position")); - Assert.That(breakdown.HavingClause.Clause, Is.EqualTo("COUNT(*) >= 3")); - Assert.That(breakdown.OrderByClause.Clause, Is.EqualTo("AvgSalary DESC")); + Assert.Multiple(() => + { + // Assert + Assert.That(breakdown.SelectClause.Clause, Contains.Substring("Department")); + Assert.That(breakdown.FromClause.Clause, Is.EqualTo("Employees")); + Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("IsActive = true")); + Assert.That(breakdown.GroupByClause.Clause, Is.EqualTo("Department, Position")); + Assert.That(breakdown.HavingClause.Clause, Is.EqualTo("COUNT(*) >= 3")); + Assert.That(breakdown.OrderByClause.Clause, Is.EqualTo("AvgSalary DESC")); + }); } [Test] @@ -396,10 +402,13 @@ public class LinqQueryBreakdownBuilderTests .OrderByAscending("Id") .Build(); - // Assert - Assert.That(breakdown.SelectClause.Clause, Contains.Substring("Id")); - Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("IsActive = true")); - Assert.That(breakdown.OrderByClause.Clause, Is.EqualTo("Id ASC")); + Assert.Multiple(() => + { + // Assert + Assert.That(breakdown.SelectClause.Clause, Contains.Substring("Id")); + Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("IsActive = true")); + Assert.That(breakdown.OrderByClause.Clause, Is.EqualTo("Id ASC")); + }); } #endregion @@ -503,9 +512,12 @@ public class LinqQueryBreakdownBuilderTests .FromTable("Orders"); var breakdown2 = builder2.Build(); - // Assert - Assert.That(breakdown1.FromClause.Clause, Is.EqualTo("Users")); - Assert.That(breakdown2.FromClause.Clause, Is.EqualTo("Orders")); + Assert.Multiple(() => + { + // Assert + Assert.That(breakdown1.FromClause.Clause, Is.EqualTo("Users")); + Assert.That(breakdown2.FromClause.Clause, Is.EqualTo("Orders")); + }); } #endregion diff --git a/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownTests.cs b/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownTests.cs index 8fbd9e0..2a7f9b3 100644 --- a/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownTests.cs +++ b/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownTests.cs @@ -27,8 +27,11 @@ public class LinqQueryBreakdownTests // Assert Assert.That(breakdown, Is.Not.Null); - Assert.That(breakdown.EntityType, Is.EqualTo(typeof(User))); - Assert.That(breakdown.FromClause?.Clause, Does.Contain("User")); + Assert.Multiple(() => + { + Assert.That(breakdown.EntityType, Is.EqualTo(typeof(User))); + Assert.That(breakdown.FromClause?.Clause, Does.Contain("User")); + }); } [Test] @@ -92,10 +95,13 @@ public class LinqQueryBreakdownTests // Act var breakdown = LinqQueryBreakdown.Analyze(query); - // Assert - Assert.That(breakdown.WhereClause?.Clause, Is.Not.Null); - Assert.That(breakdown.OrderByClause?.Clause, Is.Not.Null); - Assert.That(breakdown.SelectClause?.Clause, Is.Not.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(breakdown.WhereClause?.Clause, Is.Not.Null); + Assert.That(breakdown.OrderByClause?.Clause, Is.Not.Null); + Assert.That(breakdown.SelectClause?.Clause, Is.Not.Null); + }); } [Test] @@ -159,10 +165,13 @@ public class LinqQueryBreakdownTests // Act var success = LinqQueryBreakdown.TryAnalyze(query, out var breakdown, out var error); - // Assert - Assert.That(success, Is.True); - Assert.That(breakdown, Is.Not.Null); - Assert.That(error, Is.Empty); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.True); + Assert.That(breakdown, Is.Not.Null); + Assert.That(error, Is.Empty); + }); } [Test] @@ -174,9 +183,12 @@ public class LinqQueryBreakdownTests // Act var success = LinqQueryBreakdown.TryAnalyze(query!, out var breakdown, out var error); - // Assert - Assert.That(success, Is.False); - Assert.That(error, Is.Not.Empty); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.False); + Assert.That(error, Is.Not.Empty); + }); } [Test] @@ -194,10 +206,16 @@ public class LinqQueryBreakdownTests // Assert Assert.That(breakdown.SelectClause?.Clause, Does.Contain("Id")); Assert.That(breakdown.SelectClause?.Clause, Does.Contain("Name")); - Assert.That(breakdown.SelectClause?.Clause, Does.Contain("Email")); - Assert.That(breakdown.WhereClause?.Clause, Does.Contain("Age")); - Assert.That(breakdown.WhereClause?.Clause, Does.Contain("IsActive")); - Assert.That(breakdown.OrderByClause?.Clause, Does.Contain("Name")); + Assert.Multiple(() => + { + Assert.That(breakdown.SelectClause?.Clause, Does.Contain("Email")); + Assert.That(breakdown.WhereClause?.Clause, Does.Contain("Age")); + }); + Assert.Multiple(() => + { + Assert.That(breakdown.WhereClause?.Clause, Does.Contain("IsActive")); + Assert.That(breakdown.OrderByClause?.Clause, Does.Contain("Name")); + }); } #region Round-Trip and Query Modification Tests @@ -278,9 +296,12 @@ public class LinqQueryBreakdownTests var activeSql = activeBreakdown.GetSql(); var recentSql = recentBreakdown.GetSql(); - // Assert - Both queries are valid and different - Assert.That(activeSql, Does.Contain("IsActive")); - Assert.That(recentSql, Does.Contain("Age")); + Assert.Multiple(() => + { + // Assert - Both queries are valid and different + Assert.That(activeSql, Does.Contain("IsActive")); + Assert.That(recentSql, Does.Contain("Age")); + }); Assert.That(activeSql, Is.Not.EqualTo(recentSql)); } @@ -328,8 +349,11 @@ public class LinqQueryBreakdownTests // Assert Assert.That(paginatedSql, Does.Contain("ORDER BY")); - Assert.That(paginatedSql, Does.Contain("Id ASC")); - Assert.That(breakdown.SetupClauses, Has.Count.EqualTo(1)); + Assert.Multiple(() => + { + Assert.That(paginatedSql, Does.Contain("Id ASC")); + Assert.That(breakdown.SetupClauses, Has.Count.EqualTo(1)); + }); } [Test] @@ -351,12 +375,15 @@ public class LinqQueryBreakdownTests var hasOrdering = !string.IsNullOrEmpty(breakdown.OrderByClause?.Clause); var summary = breakdown.GetQuerySummary(); - // Assert - Verify analytics - Assert.That(methodCount, Is.GreaterThan(0)); - Assert.That(hasProjection, Is.True); - Assert.That(hasFilters, Is.True); - Assert.That(hasOrdering, Is.True); - Assert.That(summary, Does.Contain("SELECT")); + Assert.Multiple(() => + { + // Assert - Verify analytics + Assert.That(methodCount, Is.GreaterThan(0)); + Assert.That(hasProjection, Is.True); + Assert.That(hasFilters, Is.True); + Assert.That(hasOrdering, Is.True); + Assert.That(summary, Does.Contain("SELECT")); + }); Assert.That(summary, Does.Contain("WHERE")); Assert.That(summary, Does.Contain("ORDER BY")); } @@ -523,9 +550,12 @@ public class GetQueryTests var linqResult = linqBreakdown.GetQuery(); var sqlResult = sqlBreakdown.GetQuery(); - // Assert - Assert.That(linqResult, Is.Null); - Assert.That(sqlResult, Is.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(linqResult, Is.Null); + Assert.That(sqlResult, Is.Null); + }); } #endregion @@ -543,9 +573,12 @@ public class GetQueryTests // Assert Assert.That(breakdown, Is.Not.Null); - Assert.That(breakdown.TableName.Clause, Is.EqualTo("User")); - Assert.That(breakdown.InsertIntoClause.Clause, Is.Not.Empty); - Assert.That(breakdown.ValuesClause.Clause, Is.Not.Empty); + Assert.Multiple(() => + { + Assert.That(breakdown.TableName.Clause, Is.EqualTo("User")); + Assert.That(breakdown.InsertIntoClause.Clause, Is.Not.Empty); + Assert.That(breakdown.ValuesClause.Clause, Is.Not.Empty); + }); Assert.That(breakdown.InsertIntoClause.Clause, Does.Contain("Id")); Assert.That(breakdown.InsertIntoClause.Clause, Does.Contain("Name")); } @@ -565,9 +598,12 @@ public class GetQueryTests // Assert Assert.That(breakdown, Is.Not.Null); - Assert.That(breakdown.TableName.Clause, Is.EqualTo("User")); - Assert.That(breakdown.InsertIntoClause.Clause, Is.Not.Empty); - Assert.That(breakdown.ValuesClause.Clause, Does.Contain("(")); + Assert.Multiple(() => + { + Assert.That(breakdown.TableName.Clause, Is.EqualTo("User")); + Assert.That(breakdown.InsertIntoClause.Clause, Is.Not.Empty); + Assert.That(breakdown.ValuesClause.Clause, Does.Contain("(")); + }); } [Test] @@ -690,8 +726,11 @@ public class GetQueryTests // Assert Assert.That(breakdown, Is.Not.Null); - Assert.That(breakdown.ProcedureName.Clause, Is.EqualTo(procName)); - Assert.That(breakdown.Parameters, Is.Not.Empty); + Assert.Multiple(() => + { + Assert.That(breakdown.ProcedureName.Clause, Is.EqualTo(procName)); + Assert.That(breakdown.Parameters, Is.Not.Empty); + }); Assert.That(breakdown.Parameters, Has.Count.EqualTo(2)); } @@ -763,10 +802,13 @@ public class GetQueryTests // Assert Assert.That(sqlServerBreakdown, Is.Not.Null); - Assert.That(sqlServerBreakdown.SelectClause?.Clause, Is.EqualTo(breakdown.SelectClause?.Clause)); - Assert.That(sqlServerBreakdown.FromClause?.Clause, Is.EqualTo(breakdown.FromClause?.Clause)); - Assert.That(sqlServerBreakdown.WhereClause?.Clause, Is.EqualTo(breakdown.WhereClause?.Clause)); - Assert.That(sqlServerBreakdown.OrderByClause?.Clause, Is.EqualTo(breakdown.OrderByClause?.Clause)); + Assert.Multiple(() => + { + Assert.That(sqlServerBreakdown.SelectClause?.Clause, Is.EqualTo(breakdown.SelectClause?.Clause)); + Assert.That(sqlServerBreakdown.FromClause?.Clause, Is.EqualTo(breakdown.FromClause?.Clause)); + Assert.That(sqlServerBreakdown.WhereClause?.Clause, Is.EqualTo(breakdown.WhereClause?.Clause)); + Assert.That(sqlServerBreakdown.OrderByClause?.Clause, Is.EqualTo(breakdown.OrderByClause?.Clause)); + }); } [Test] @@ -784,10 +826,13 @@ public class GetQueryTests // Assert Assert.That(postgresBreakdown, Is.Not.Null); - Assert.That(postgresBreakdown.SelectClause?.Clause, Is.EqualTo(breakdown.SelectClause?.Clause)); - Assert.That(postgresBreakdown.FromClause?.Clause, Is.EqualTo(breakdown.FromClause?.Clause)); - Assert.That(postgresBreakdown.WhereClause?.Clause, Is.EqualTo(breakdown.WhereClause?.Clause)); - Assert.That(postgresBreakdown.OrderByClause?.Clause, Is.EqualTo(breakdown.OrderByClause?.Clause)); + Assert.Multiple(() => + { + Assert.That(postgresBreakdown.SelectClause?.Clause, Is.EqualTo(breakdown.SelectClause?.Clause)); + Assert.That(postgresBreakdown.FromClause?.Clause, Is.EqualTo(breakdown.FromClause?.Clause)); + Assert.That(postgresBreakdown.WhereClause?.Clause, Is.EqualTo(breakdown.WhereClause?.Clause)); + Assert.That(postgresBreakdown.OrderByClause?.Clause, Is.EqualTo(breakdown.OrderByClause?.Clause)); + }); } [Test] @@ -802,10 +847,13 @@ public class GetQueryTests // Assert Assert.That(snowflakeBreakdown, Is.Not.Null); - Assert.That(snowflakeBreakdown.SelectClause?.Clause, Is.EqualTo(breakdown.SelectClause?.Clause)); - Assert.That(snowflakeBreakdown.FromClause?.Clause, Is.EqualTo(breakdown.FromClause?.Clause)); - Assert.That(snowflakeBreakdown.WhereClause?.Clause, Is.EqualTo(breakdown.WhereClause?.Clause)); - Assert.That(snowflakeBreakdown.OrderByClause?.Clause, Is.EqualTo(breakdown.OrderByClause?.Clause)); + Assert.Multiple(() => + { + Assert.That(snowflakeBreakdown.SelectClause?.Clause, Is.EqualTo(breakdown.SelectClause?.Clause)); + Assert.That(snowflakeBreakdown.FromClause?.Clause, Is.EqualTo(breakdown.FromClause?.Clause)); + Assert.That(snowflakeBreakdown.WhereClause?.Clause, Is.EqualTo(breakdown.WhereClause?.Clause)); + Assert.That(snowflakeBreakdown.OrderByClause?.Clause, Is.EqualTo(breakdown.OrderByClause?.Clause)); + }); } [Test] @@ -819,9 +867,12 @@ public class GetQueryTests // Act var sqlServerBreakdown = breakdown.ConvertToSqlServerBreakdown(); - // Assert - Assert.That(sqlServerBreakdown.SelectClause?.Comment, Is.EqualTo("Select user columns")); - Assert.That(sqlServerBreakdown.WhereClause?.Comment, Is.EqualTo("Filter adult users")); + Assert.Multiple(() => + { + // Assert + Assert.That(sqlServerBreakdown.SelectClause?.Comment, Is.EqualTo("Select user columns")); + Assert.That(sqlServerBreakdown.WhereClause?.Comment, Is.EqualTo("Filter adult users")); + }); } [Test] @@ -837,12 +888,15 @@ public class GetQueryTests // Act var postgresBreakdown = breakdown.ConvertToPostgreSqlBreakdown(); - // Assert - Assert.That(postgresBreakdown.SelectClause?.Clause, Is.Not.Null); - Assert.That(postgresBreakdown.FromClause?.Clause, Is.Not.Null); - Assert.That(postgresBreakdown.WhereClause?.Clause, Is.Not.Null); - Assert.That(postgresBreakdown.GroupByClause?.Clause, Is.Not.Null); - Assert.That(postgresBreakdown.OrderByClause?.Clause, Is.Not.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(postgresBreakdown.SelectClause?.Clause, Is.Not.Null); + Assert.That(postgresBreakdown.FromClause?.Clause, Is.Not.Null); + Assert.That(postgresBreakdown.WhereClause?.Clause, Is.Not.Null); + Assert.That(postgresBreakdown.GroupByClause?.Clause, Is.Not.Null); + Assert.That(postgresBreakdown.OrderByClause?.Clause, Is.Not.Null); + }); } [Test] @@ -854,9 +908,12 @@ public class GetQueryTests // Act var snowflakeBreakdown = breakdown.ConvertToSnowflakeBreakdown(); - // Assert - Assert.That(snowflakeBreakdown.FromClause?.Clause, Is.EqualTo(breakdown.FromClause?.Clause)); - Assert.That(snowflakeBreakdown.OrderByClause?.Clause, Is.EqualTo(breakdown.OrderByClause?.Clause)); + Assert.Multiple(() => + { + // Assert + Assert.That(snowflakeBreakdown.FromClause?.Clause, Is.EqualTo(breakdown.FromClause?.Clause)); + Assert.That(snowflakeBreakdown.OrderByClause?.Clause, Is.EqualTo(breakdown.OrderByClause?.Clause)); + }); } [Test] diff --git a/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownWithClauseTests.cs b/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownWithClauseTests.cs index 8196ac2..30aa81f 100644 --- a/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownWithClauseTests.cs +++ b/tests/Strata.SqlTools.LinqToSql.Tests/LinqQueryBreakdownWithClauseTests.cs @@ -21,8 +21,11 @@ public class LinqQueryBreakdownWithClauseTests // Assert Assert.That(mainQuery.WithClauses, Has.Count.EqualTo(1)); - Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("active_users")); - Assert.That(mainQuery.WithClauses[0].Query, Is.EqualTo(cte)); + Assert.Multiple(() => + { + Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("active_users")); + Assert.That(mainQuery.WithClauses[0].Query, Is.EqualTo(cte)); + }); } [Test] @@ -81,8 +84,11 @@ public class LinqQueryBreakdownWithClauseTests // Assert var keys = merged.Keys.ToList(); - Assert.That(keys.Any(k => k.Contains("Status")), "Should include CTE parameters"); - Assert.That(keys.Any(k => k.Contains("Limit")), "Should include main query parameters"); + Assert.Multiple(() => + { + Assert.That(keys.Any(k => k.Contains("Status")), "Should include CTE parameters"); + Assert.That(keys.Any(k => k.Contains("Limit")), "Should include main query parameters"); + }); } [Test] @@ -101,8 +107,11 @@ public class LinqQueryBreakdownWithClauseTests // Assert var valueKey = merged.Keys.FirstOrDefault(k => k.Contains("Value")); - 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.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"); + }); } #endregion @@ -152,8 +161,11 @@ public class LinqQueryBreakdownWithClauseTests // Assert Assert.That(query.WithClauses, Has.Count.EqualTo(2)); var keys = merged.Keys.ToList(); - Assert.That(keys.Any(k => k.Contains("MinDate"))); - Assert.That(keys.Any(k => k.Contains("Status"))); + Assert.Multiple(() => + { + Assert.That(keys.Any(k => k.Contains("MinDate"))); + Assert.That(keys.Any(k => k.Contains("Status"))); + }); } #endregion @@ -213,9 +225,12 @@ public class LinqQueryBreakdownWithClauseTests // Assert var keys = merged.Keys.ToList(); - Assert.That(keys.Any(k => k.Contains("AnchorLevel")), "Should include anchor parameters"); - Assert.That(keys.Any(k => k.Contains("MaxLevel")), "Should include recursive parameters"); - Assert.That(keys.Any(k => k.Contains("QueryLimit")), "Should include main query parameters"); + Assert.Multiple(() => + { + Assert.That(keys.Any(k => k.Contains("AnchorLevel")), "Should include anchor parameters"); + Assert.That(keys.Any(k => k.Contains("MaxLevel")), "Should include recursive parameters"); + Assert.That(keys.Any(k => k.Contains("QueryLimit")), "Should include main query parameters"); + }); } #endregion @@ -279,10 +294,13 @@ public class LinqQueryBreakdownWithClauseTests // Assert var keys = merged.Keys.ToList(); - Assert.That(keys.Any(k => k.Contains("InnerParam"))); - Assert.That(keys.Any(k => k.Contains("OuterParam"))); - Assert.That(keys.Any(k => k.Contains("MainParam"))); - Assert.That(sql, Contains.Substring("WITH")); + Assert.Multiple(() => + { + Assert.That(keys.Any(k => k.Contains("InnerParam"))); + Assert.That(keys.Any(k => k.Contains("OuterParam"))); + Assert.That(keys.Any(k => k.Contains("MainParam"))); + Assert.That(sql, Contains.Substring("WITH")); + }); } #endregion diff --git a/tests/Strata.SqlTools.LinqToSql.Tests/QueryCollectionAnalyzerTests.cs b/tests/Strata.SqlTools.LinqToSql.Tests/QueryCollectionAnalyzerTests.cs index 9932bdd..2565e5a 100644 --- a/tests/Strata.SqlTools.LinqToSql.Tests/QueryCollectionAnalyzerTests.cs +++ b/tests/Strata.SqlTools.LinqToSql.Tests/QueryCollectionAnalyzerTests.cs @@ -19,10 +19,13 @@ public class QueryCollectionAnalyzerTests // Act var stats = analyzer.Analyze(); - // Assert - Assert.That(stats.TotalQueries, Is.EqualTo(0)); - Assert.That(stats.UniqueQueries, Is.EqualTo(0)); - Assert.That(stats.DuplicateQueries, Is.Empty); + Assert.Multiple(() => + { + // Assert + Assert.That(stats.TotalQueries, Is.EqualTo(0)); + Assert.That(stats.UniqueQueries, Is.EqualTo(0)); + Assert.That(stats.DuplicateQueries, Is.Empty); + }); } [Test] @@ -43,10 +46,13 @@ public class QueryCollectionAnalyzerTests // Act var stats = analyzer.Analyze(); - // Assert - Assert.That(stats.TotalQueries, Is.EqualTo(1)); - Assert.That(stats.UniqueQueries, Is.EqualTo(1)); - Assert.That(stats.DuplicateQueries, Is.Empty); + Assert.Multiple(() => + { + // Assert + Assert.That(stats.TotalQueries, Is.EqualTo(1)); + Assert.That(stats.UniqueQueries, Is.EqualTo(1)); + Assert.That(stats.DuplicateQueries, Is.Empty); + }); } [Test] @@ -77,10 +83,13 @@ public class QueryCollectionAnalyzerTests // Act var stats = analyzer.Analyze(); - // Assert - Assert.That(stats.TotalQueries, Is.EqualTo(3)); - Assert.That(stats.UniqueQueries, Is.EqualTo(1)); - Assert.That(stats.DuplicateQueries, Has.Count.EqualTo(2)); + Assert.Multiple(() => + { + // Assert + Assert.That(stats.TotalQueries, Is.EqualTo(3)); + Assert.That(stats.UniqueQueries, Is.EqualTo(1)); + Assert.That(stats.DuplicateQueries, Has.Count.EqualTo(2)); + }); } #endregion @@ -207,9 +216,12 @@ public class QueryCollectionAnalyzerTests // Act var stats = analyzer.Analyze(); - // Assert - Assert.That(stats.TableUsageFrequency["Users"], Is.EqualTo(3)); - Assert.That(stats.TableUsageFrequency["Orders"], Is.EqualTo(1)); + Assert.Multiple(() => + { + // Assert + Assert.That(stats.TableUsageFrequency["Users"], Is.EqualTo(3)); + Assert.That(stats.TableUsageFrequency["Orders"], Is.EqualTo(1)); + }); } [Test] @@ -246,11 +258,14 @@ public class QueryCollectionAnalyzerTests // Act var stats = analyzer.Analyze(); - // Assert - Assert.That(stats.ColumnSelectionFrequency.ContainsKey("Id"), Is.True); - Assert.That(stats.ColumnSelectionFrequency["Id"], Is.EqualTo(3)); - Assert.That(stats.ColumnSelectionFrequency["Name"], Is.EqualTo(2)); - Assert.That(stats.ColumnSelectionFrequency["Email"], Is.EqualTo(1)); + Assert.Multiple(() => + { + // Assert + Assert.That(stats.ColumnSelectionFrequency.ContainsKey("Id"), Is.True); + Assert.That(stats.ColumnSelectionFrequency["Id"], Is.EqualTo(3)); + Assert.That(stats.ColumnSelectionFrequency["Name"], Is.EqualTo(2)); + Assert.That(stats.ColumnSelectionFrequency["Email"], Is.EqualTo(1)); + }); } [Test] @@ -267,9 +282,12 @@ public class QueryCollectionAnalyzerTests // Act var stats = analyzer.Analyze(); - // Assert - Assert.That(stats.ColumnSelectionFrequency.ContainsKey("*"), Is.False); - Assert.That(stats.ColumnSelectionFrequency["Id"], Is.EqualTo(1)); + Assert.Multiple(() => + { + // Assert + Assert.That(stats.ColumnSelectionFrequency.ContainsKey("*"), Is.False); + Assert.That(stats.ColumnSelectionFrequency["Id"], Is.EqualTo(1)); + }); } #endregion @@ -488,9 +506,12 @@ public class QueryCollectionAnalyzerTests // Act var stats = analyzer.Analyze(); - // Assert - Assert.That(stats.TotalQueries, Is.EqualTo(100)); - Assert.That(stats.UniqueQueries, Is.EqualTo(1)); + Assert.Multiple(() => + { + // Assert + Assert.That(stats.TotalQueries, Is.EqualTo(100)); + Assert.That(stats.UniqueQueries, Is.EqualTo(1)); + }); } #endregion diff --git a/tests/Strata.SqlTools.LinqToSql.Tests/QueryValidatorTests.cs b/tests/Strata.SqlTools.LinqToSql.Tests/QueryValidatorTests.cs index 4dcfbec..3c49fd0 100644 --- a/tests/Strata.SqlTools.LinqToSql.Tests/QueryValidatorTests.cs +++ b/tests/Strata.SqlTools.LinqToSql.Tests/QueryValidatorTests.cs @@ -62,9 +62,12 @@ public class QueryValidatorTests validator.Validate(breakdown2); var count2 = validator.Issues.Count; - // Assert - Assert.That(count1, Is.GreaterThan(0)); - Assert.That(count2, Is.GreaterThan(0)); + Assert.Multiple(() => + { + // Assert + Assert.That(count1, Is.GreaterThan(0)); + Assert.That(count2, Is.GreaterThan(0)); + }); } #endregion @@ -324,10 +327,13 @@ public class QueryValidatorTests var infos = validator.GetIssuesBySeverity(ValidationSeverity.Info); var errors = validator.GetIssuesBySeverity(ValidationSeverity.Error); - // Assert - Assert.That(warnings, Is.Not.Empty); - Assert.That(infos, Is.Not.Empty); - Assert.That(errors, Is.Empty); + Assert.Multiple(() => + { + // Assert + Assert.That(warnings, Is.Not.Empty); + Assert.That(infos, Is.Not.Empty); + Assert.That(errors, Is.Empty); + }); } #endregion @@ -349,8 +355,11 @@ public class QueryValidatorTests // Assert Assert.That(validator.Issues, Has.Count.EqualTo(1)); - Assert.That(validator.Issues[0].Code, Is.EqualTo("CUSTOM_001")); - Assert.That(validator.HasErrors, Is.True); + Assert.Multiple(() => + { + Assert.That(validator.Issues[0].Code, Is.EqualTo("CUSTOM_001")); + Assert.That(validator.HasErrors, Is.True); + }); } [Test] @@ -365,9 +374,12 @@ public class QueryValidatorTests .AddIssue(ValidationSeverity.Warning, "WARN_001", "Warning 1") .AddIssue(ValidationSeverity.Info, "INFO_001", "Info 1"); - // Assert - Assert.That(result, Is.SameAs(validator)); - Assert.That(validator.Issues, Has.Count.EqualTo(3)); + Assert.Multiple(() => + { + // Assert + Assert.That(result, Is.SameAs(validator)); + Assert.That(validator.Issues, Has.Count.EqualTo(3)); + }); } #endregion @@ -480,9 +492,12 @@ public class QueryValidatorTests // Act var validator = QueryValidator.ValidateQuery(breakdown); - // Assert - Assert.That(validator.Issues.Count, Is.GreaterThan(1)); - Assert.That(validator.HasWarnings, Is.True); + Assert.Multiple(() => + { + // Assert + Assert.That(validator.Issues.Count, Is.GreaterThan(1)); + Assert.That(validator.HasWarnings, Is.True); + }); } [Test] diff --git a/tests/Strata.SqlTools.LinqToSql.Tests/ReverseConverterTests.cs b/tests/Strata.SqlTools.LinqToSql.Tests/ReverseConverterTests.cs index 1d14113..9120525 100644 --- a/tests/Strata.SqlTools.LinqToSql.Tests/ReverseConverterTests.cs +++ b/tests/Strata.SqlTools.LinqToSql.Tests/ReverseConverterTests.cs @@ -27,10 +27,13 @@ public class ReverseConverterTests // Assert Assert.That(linqBreakdown, Is.Not.Null); - Assert.That(linqBreakdown.SelectClause.Clause, Contains.Substring("Id")); - Assert.That(linqBreakdown.FromClause.Clause, Is.EqualTo("Users")); - Assert.That(linqBreakdown.WhereClause.Clause, Is.EqualTo("IsActive = 1")); - Assert.That(linqBreakdown.OrderByClause.Clause, Is.EqualTo("Name ASC")); + Assert.Multiple(() => + { + Assert.That(linqBreakdown.SelectClause.Clause, Contains.Substring("Id")); + Assert.That(linqBreakdown.FromClause.Clause, Is.EqualTo("Users")); + Assert.That(linqBreakdown.WhereClause.Clause, Is.EqualTo("IsActive = 1")); + Assert.That(linqBreakdown.OrderByClause.Clause, Is.EqualTo("Name ASC")); + }); } [Test] @@ -46,9 +49,12 @@ public class ReverseConverterTests // Act var linqBreakdown = sqlServerBreakdown.ToLinqQueryBreakdown(); - // Assert - Assert.That(linqBreakdown.GroupByClause.Clause, Is.EqualTo("Department")); - Assert.That(linqBreakdown.HavingClause.Clause, Is.EqualTo("COUNT(*) > 5")); + Assert.Multiple(() => + { + // Assert + Assert.That(linqBreakdown.GroupByClause.Clause, Is.EqualTo("Department")); + Assert.That(linqBreakdown.HavingClause.Clause, Is.EqualTo("COUNT(*) > 5")); + }); } [Test] @@ -81,9 +87,12 @@ public class ReverseConverterTests // Assert Assert.That(linqBreakdown, Is.Not.Null); - Assert.That(linqBreakdown.SelectClause.Clause, Contains.Substring("user_id")); - Assert.That(linqBreakdown.FromClause.Clause, Is.EqualTo("users")); - Assert.That(linqBreakdown.WhereClause.Clause, Is.EqualTo("is_active = true")); + Assert.Multiple(() => + { + Assert.That(linqBreakdown.SelectClause.Clause, Contains.Substring("user_id")); + Assert.That(linqBreakdown.FromClause.Clause, Is.EqualTo("users")); + Assert.That(linqBreakdown.WhereClause.Clause, Is.EqualTo("is_active = true")); + }); } [Test] @@ -116,9 +125,12 @@ public class ReverseConverterTests // Assert Assert.That(linqBreakdown, Is.Not.Null); - Assert.That(linqBreakdown.SelectClause.Clause, Contains.Substring("USER_ID")); - Assert.That(linqBreakdown.FromClause.Clause, Is.EqualTo("USERS")); - Assert.That(linqBreakdown.WhereClause.Clause, Is.EqualTo("IS_ACTIVE = TRUE")); + Assert.Multiple(() => + { + Assert.That(linqBreakdown.SelectClause.Clause, Contains.Substring("USER_ID")); + Assert.That(linqBreakdown.FromClause.Clause, Is.EqualTo("USERS")); + Assert.That(linqBreakdown.WhereClause.Clause, Is.EqualTo("IS_ACTIVE = TRUE")); + }); } [Test] @@ -252,10 +264,13 @@ public class ReverseConverterTests var result2 = sqlServerBreakdown.ConvertToDialect("POSTGRESQL"); var result3 = sqlServerBreakdown.ConvertToDialect("postgresql"); - // Assert - Assert.That(result1, Is.TypeOf()); - Assert.That(result2, Is.TypeOf()); - Assert.That(result3, Is.TypeOf()); + Assert.Multiple(() => + { + // Assert + Assert.That(result1, Is.TypeOf()); + Assert.That(result2, Is.TypeOf()); + Assert.That(result3, Is.TypeOf()); + }); } #endregion @@ -281,10 +296,13 @@ public class ReverseConverterTests var backToLinq2 = toPostgres!.ToLinqQueryBreakdown(); var finalToSqlServer = backToLinq2.ConvertToSqlServerBreakdown(); - // Assert - Check that clauses are preserved - Assert.That(backToLinq.SelectClause.Clause, Contains.Substring("Id")); - Assert.That(backToLinq.FromClause.Clause, Is.EqualTo("Users")); - Assert.That(backToLinq.WhereClause.Clause, Is.EqualTo("IsActive = true")); + Assert.Multiple(() => + { + // Assert - Check that clauses are preserved + Assert.That(backToLinq.SelectClause.Clause, Contains.Substring("Id")); + Assert.That(backToLinq.FromClause.Clause, Is.EqualTo("Users")); + Assert.That(backToLinq.WhereClause.Clause, Is.EqualTo("IsActive = true")); + }); } #endregion @@ -333,11 +351,14 @@ public class ReverseConverterTests var resultSqlServer1 = sqlServerBreakdown.ConvertToDialect("sqlserver"); var resultSqlServer2 = sqlServerBreakdown.ConvertToDialect("sql_server"); - // Assert - Assert.That(resultPostgres1, Is.TypeOf()); - Assert.That(resultPostgres2, Is.TypeOf()); - Assert.That(resultSqlServer1, Is.SameAs(sqlServerBreakdown)); - Assert.That(resultSqlServer2, Is.SameAs(sqlServerBreakdown)); + Assert.Multiple(() => + { + // Assert + Assert.That(resultPostgres1, Is.TypeOf()); + Assert.That(resultPostgres2, Is.TypeOf()); + Assert.That(resultSqlServer1, Is.SameAs(sqlServerBreakdown)); + Assert.That(resultSqlServer2, Is.SameAs(sqlServerBreakdown)); + }); } #endregion diff --git a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/CTEColumnListTests.cs b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/CTEColumnListTests.cs index 7859af4..4b865ea 100644 --- a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/CTEColumnListTests.cs +++ b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/CTEColumnListTests.cs @@ -20,9 +20,12 @@ public class CTEColumnListTests // Act & Assert Assert.That(withClause.ColumnList, Has.Count.EqualTo(3)); - Assert.That(withClause.ColumnList[0], Is.EqualTo("user_id")); - Assert.That(withClause.ColumnList[1], Is.EqualTo("user_name")); - Assert.That(withClause.ColumnList[2], Is.EqualTo("user_email")); + Assert.Multiple(() => + { + Assert.That(withClause.ColumnList[0], Is.EqualTo("user_id")); + Assert.That(withClause.ColumnList[1], Is.EqualTo("user_name")); + Assert.That(withClause.ColumnList[2], Is.EqualTo("user_email")); + }); } [Test] @@ -269,8 +272,11 @@ public class CTEColumnListTests // Assert Assert.That(sql, Contains.Substring("customer_transactions (trans_date, prod_id, cust_id, trans_amount, transaction_rank)")); var paramKeys = params_all.Keys.ToList(); - Assert.That(paramKeys.Any(k => k.Contains("StartDate"))); - Assert.That(paramKeys.Any(k => k.Contains("MinAmount"))); + Assert.Multiple(() => + { + Assert.That(paramKeys.Any(k => k.Contains("StartDate"))); + Assert.That(paramKeys.Any(k => k.Contains("MinAmount"))); + }); } #endregion diff --git a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownCollectionTests.cs b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownCollectionTests.cs index 28865e1..0d48c3e 100644 --- a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownCollectionTests.cs +++ b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownCollectionTests.cs @@ -182,9 +182,12 @@ public class QueryBreakdownCollectionTests // Act var result = _collection.ParseBatch(batchSql); - // Assert - Assert.That(result, Is.True); - Assert.That(_collection.Count, Is.GreaterThan(0)); + Assert.Multiple(() => + { + // Assert + Assert.That(result, Is.True); + Assert.That(_collection.Count, Is.GreaterThan(0)); + }); } [Test] @@ -199,9 +202,12 @@ public class QueryBreakdownCollectionTests // Act var result = _collection.ParseBatch(batchSql); - // Assert - Assert.That(result, Is.True); - Assert.That(_collection.Count, Is.GreaterThan(0)); + Assert.Multiple(() => + { + // Assert + Assert.That(result, Is.True); + Assert.That(_collection.Count, Is.GreaterThan(0)); + }); } [Test] @@ -284,8 +290,11 @@ public class QueryBreakdownCollectionTests // Assert Assert.That(sql, Does.Contain("SELECT")); - Assert.That(sql, Does.Contain(";")); - Assert.That(_collection, Has.Count.EqualTo(3)); + Assert.Multiple(() => + { + Assert.That(sql, Does.Contain(";")); + Assert.That(_collection, Has.Count.EqualTo(3)); + }); } #endregion diff --git a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownTests.cs b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownTests.cs index 542d615..9d10aae 100644 --- a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownTests.cs +++ b/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()); + Assert.Multiple(() => + { + Assert.That(dateKey, Is.Not.Null); + Assert.That(merged[dateKey], Is.TypeOf()); - Assert.That(boolKey, Is.Not.Null); - Assert.That(merged[boolKey], Is.TypeOf()); + Assert.That(boolKey, Is.Not.Null); + Assert.That(merged[boolKey], Is.TypeOf()); - Assert.That(doubleKey, Is.Not.Null); - Assert.That(merged[doubleKey], Is.TypeOf()); + Assert.That(doubleKey, Is.Not.Null); + Assert.That(merged[doubleKey], Is.TypeOf()); + }); } #endregion diff --git a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/RecursiveCTETests.cs b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/RecursiveCTETests.cs index 291b2e6..4d04800 100644 --- a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/RecursiveCTETests.cs +++ b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/RecursiveCTETests.cs @@ -33,9 +33,12 @@ public class RecursiveCTETests var isRecursive = withClause.IsRecursive; var hasRecursiveQuery = withClause.RecursiveQuery != null; - // Assert - Assert.That(isRecursive, Is.True); - Assert.That(hasRecursiveQuery, Is.True); + Assert.Multiple(() => + { + // Assert + Assert.That(isRecursive, Is.True); + Assert.That(hasRecursiveQuery, Is.True); + }); } [Test] @@ -143,10 +146,13 @@ public class RecursiveCTETests // Assert var keys = merged.Keys.ToList(); - Assert.That(keys.Any(k => k.Contains("AnchorStatus")), "Should include anchor query parameters"); - Assert.That(keys.Any(k => k.Contains("RecursiveLevel")), "Should include recursive query parameters"); - Assert.That(keys.Any(k => k.Contains("RecursiveStatus")), "Should include recurring query parameters"); - Assert.That(keys.Any(k => k.Contains("MainLimit")), "Should include main query parameters"); + Assert.Multiple(() => + { + Assert.That(keys.Any(k => k.Contains("AnchorStatus")), "Should include anchor query parameters"); + Assert.That(keys.Any(k => k.Contains("RecursiveLevel")), "Should include recursive query parameters"); + Assert.That(keys.Any(k => k.Contains("RecursiveStatus")), "Should include recurring query parameters"); + Assert.That(keys.Any(k => k.Contains("MainLimit")), "Should include main query parameters"); + }); } [Test] @@ -176,8 +182,11 @@ public class RecursiveCTETests // Assert // PostgreSQL stores parameters with positional syntax var statusKey = merged.Keys.FirstOrDefault(k => k.Contains("Status") && !k.StartsWith('$')); - Assert.That(statusKey, Is.Not.Null); - Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence"); + Assert.Multiple(() => + { + Assert.That(statusKey, Is.Not.Null); + Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence"); + }); } #endregion diff --git a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/StatementReaderTests.cs b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/StatementReaderTests.cs index 318c9ac..c0d1449 100644 --- a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/StatementReaderTests.cs +++ b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/StatementReaderTests.cs @@ -23,9 +23,12 @@ public class StatementReaderTests // Assert Assert.That(tokens, Is.Not.Empty); - Assert.That(tokens[0].Type, Is.EqualTo(TokenType.LeftParenthesis)); - Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Number)); - Assert.That(tokens[1].Value, Is.EqualTo("1")); + Assert.Multiple(() => + { + Assert.That(tokens[0].Type, Is.EqualTo(TokenType.LeftParenthesis)); + Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Number)); + Assert.That(tokens[1].Value, Is.EqualTo("1")); + }); } [Test] @@ -44,10 +47,13 @@ public class StatementReaderTests // Assert Assert.That(tokens, Has.Count.EqualTo(5)); // "COLUMN_1" + "COLUMN_2" * 2 - Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier)); - Assert.That(tokens[0].Value, Is.EqualTo("COLUMN_1")); - Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus)); - Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier)); + Assert.Multiple(() => + { + Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier)); + Assert.That(tokens[0].Value, Is.EqualTo("COLUMN_1")); + Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus)); + Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier)); + }); } [Test] @@ -64,11 +70,14 @@ public class StatementReaderTests tokens.Add((sqlReader.TokenType, sqlReader.TokenValue)); } - // Assert - Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier)); - Assert.That(tokens[0].Value, Is.EqualTo("MyColumn")); - Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier)); - Assert.That(tokens[2].Value, Is.EqualTo("AnotherColumn")); + Assert.Multiple(() => + { + // Assert + Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier)); + Assert.That(tokens[0].Value, Is.EqualTo("MyColumn")); + Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier)); + Assert.That(tokens[2].Value, Is.EqualTo("AnotherColumn")); + }); } [Test] @@ -89,8 +98,11 @@ public class StatementReaderTests Assert.That(tokens.Count, Is.GreaterThan(0)); var paramTokens = tokens.Where(t => t.Type == TokenType.Parameter).ToList(); Assert.That(paramTokens, Has.Count.EqualTo(2)); - Assert.That(paramTokens[0].Value, Is.EqualTo("$1")); - Assert.That(paramTokens[1].Value, Is.EqualTo("$2")); + Assert.Multiple(() => + { + Assert.That(paramTokens[0].Value, Is.EqualTo("$1")); + Assert.That(paramTokens[1].Value, Is.EqualTo("$2")); + }); } [Test] diff --git a/tests/Strata.SqlTools.Rules.Tests/MarkdownParserTests.cs b/tests/Strata.SqlTools.Rules.Tests/MarkdownParserTests.cs index 3097f8c..ede4576 100644 --- a/tests/Strata.SqlTools.Rules.Tests/MarkdownParserTests.cs +++ b/tests/Strata.SqlTools.Rules.Tests/MarkdownParserTests.cs @@ -12,8 +12,11 @@ public class MarkdownParserTests { var result = Markdown.Parse("42"); - Assert.That(result, Is.InstanceOf()); - Assert.That(((NumberLiteral)result).Value, Is.EqualTo(42m)); + Assert.Multiple(() => + { + Assert.That(result, Is.InstanceOf()); + Assert.That(((NumberLiteral)result).Value, Is.EqualTo(42m)); + }); } [Test] @@ -21,8 +24,11 @@ public class MarkdownParserTests { var result = Markdown.Parse("3.14"); - Assert.That(result, Is.InstanceOf()); - Assert.That(((NumberLiteral)result).Value, Is.EqualTo(3.14m)); + Assert.Multiple(() => + { + Assert.That(result, Is.InstanceOf()); + Assert.That(((NumberLiteral)result).Value, Is.EqualTo(3.14m)); + }); } [Test] @@ -30,8 +36,11 @@ public class MarkdownParserTests { var result = Markdown.Parse("\"hello world\""); - Assert.That(result, Is.InstanceOf()); - Assert.That(((StringLiteral)result).Value, Is.EqualTo("hello world")); + Assert.Multiple(() => + { + Assert.That(result, Is.InstanceOf()); + Assert.That(((StringLiteral)result).Value, Is.EqualTo("hello world")); + }); } [Test] @@ -39,8 +48,11 @@ public class MarkdownParserTests { var result = Markdown.Parse("'test string'"); - Assert.That(result, Is.InstanceOf()); - Assert.That(((StringLiteral)result).Value, Is.EqualTo("test string")); + Assert.Multiple(() => + { + Assert.That(result, Is.InstanceOf()); + Assert.That(((StringLiteral)result).Value, Is.EqualTo("test string")); + }); } [Test] @@ -48,8 +60,11 @@ public class MarkdownParserTests { var result = Markdown.Parse("true"); - Assert.That(result, Is.InstanceOf()); - Assert.That(((Literal)result).Value, Is.EqualTo(true)); + Assert.Multiple(() => + { + Assert.That(result, Is.InstanceOf()); + Assert.That(((Literal)result).Value, Is.EqualTo(true)); + }); } [Test] @@ -57,8 +72,11 @@ public class MarkdownParserTests { var result = Markdown.Parse("false"); - Assert.That(result, Is.InstanceOf()); - Assert.That(((Literal)result).Value, Is.EqualTo(false)); + Assert.Multiple(() => + { + Assert.That(result, Is.InstanceOf()); + Assert.That(((Literal)result).Value, Is.EqualTo(false)); + }); } #endregion @@ -72,8 +90,11 @@ public class MarkdownParserTests Assert.That(result, Is.InstanceOf()); var prop = (Property)result; - Assert.That(prop.PropertyName, Is.EqualTo("PropertyName")); - Assert.That(prop.Expression, Is.Null); + Assert.Multiple(() => + { + Assert.That(prop.PropertyName, Is.EqualTo("PropertyName")); + Assert.That(prop.Expression, Is.Null); + }); } [Test] @@ -83,8 +104,11 @@ public class MarkdownParserTests Assert.That(result, Is.InstanceOf()); var prop = (Property)result; - Assert.That(prop.PropertyName, Is.EqualTo("Age")); - Assert.That(prop.Expression, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(prop.PropertyName, Is.EqualTo("Age")); + Assert.That(prop.Expression, Is.InstanceOf()); + }); } [Test] @@ -94,8 +118,11 @@ public class MarkdownParserTests Assert.That(result, Is.InstanceOf()); var prop = (Property)result; - Assert.That(prop.PropertyName, Is.EqualTo("Department")); - Assert.That(prop.Expression, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(prop.PropertyName, Is.EqualTo("Department")); + Assert.That(prop.Expression, Is.InstanceOf()); + }); } [Test] @@ -103,8 +130,11 @@ public class MarkdownParserTests { var result = Markdown.Parse("\\text{some text}"); - Assert.That(result, Is.InstanceOf()); - Assert.That(((StringLiteral)result).Value, Is.EqualTo("some text")); + Assert.Multiple(() => + { + Assert.That(result, Is.InstanceOf()); + Assert.That(((StringLiteral)result).Value, Is.EqualTo("some text")); + }); } #endregion @@ -118,8 +148,11 @@ public class MarkdownParserTests Assert.That(result, Is.InstanceOf()); var equal = (Equal)result; - Assert.That(equal.Left, Is.InstanceOf()); - Assert.That(equal.Right, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(equal.Left, Is.InstanceOf()); + Assert.That(equal.Right, Is.InstanceOf()); + }); } [Test] @@ -129,8 +162,11 @@ public class MarkdownParserTests Assert.That(result, Is.InstanceOf()); var notEqual = (NotEqual)result; - Assert.That(notEqual.Left, Is.InstanceOf()); - Assert.That(notEqual.Right, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(notEqual.Left, Is.InstanceOf()); + Assert.That(notEqual.Right, Is.InstanceOf()); + }); } [Test] @@ -140,8 +176,11 @@ public class MarkdownParserTests Assert.That(result, Is.InstanceOf()); var notEqual = (NotEqual)result; - Assert.That(notEqual.Left, Is.InstanceOf()); - Assert.That(notEqual.Right, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(notEqual.Left, Is.InstanceOf()); + Assert.That(notEqual.Right, Is.InstanceOf()); + }); } [Test] @@ -151,8 +190,11 @@ public class MarkdownParserTests Assert.That(result, Is.InstanceOf()); var greaterThan = (GreaterThan)result; - Assert.That(greaterThan.Left, Is.InstanceOf()); - Assert.That(greaterThan.Right, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(greaterThan.Left, Is.InstanceOf()); + Assert.That(greaterThan.Right, Is.InstanceOf()); + }); } [Test] @@ -162,8 +204,11 @@ public class MarkdownParserTests Assert.That(result, Is.InstanceOf()); var greaterThan = (GreaterThan)result; - Assert.That(greaterThan.Left, Is.InstanceOf()); - Assert.That(greaterThan.Right, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(greaterThan.Left, Is.InstanceOf()); + Assert.That(greaterThan.Right, Is.InstanceOf()); + }); } #endregion @@ -177,8 +222,11 @@ public class MarkdownParserTests Assert.That(result, Is.InstanceOf()); var and = (And)result; - Assert.That(and.Left, Is.InstanceOf()); - Assert.That(and.Right, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(and.Left, Is.InstanceOf()); + Assert.That(and.Right, Is.InstanceOf()); + }); } [Test] @@ -188,8 +236,11 @@ public class MarkdownParserTests Assert.That(result, Is.InstanceOf()); var or = (Or)result; - Assert.That(or.Left, Is.InstanceOf()); - Assert.That(or.Right, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(or.Left, Is.InstanceOf()); + Assert.That(or.Right, Is.InstanceOf()); + }); } [Test] @@ -199,8 +250,11 @@ public class MarkdownParserTests Assert.That(result, Is.InstanceOf()); var and = (And)result; - Assert.That(and.Left, Is.InstanceOf()); - Assert.That(and.Right, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(and.Left, Is.InstanceOf()); + Assert.That(and.Right, Is.InstanceOf()); + }); } [Test] @@ -210,8 +264,11 @@ public class MarkdownParserTests Assert.That(result, Is.InstanceOf()); var or = (Or)result; - Assert.That(or.Left, Is.InstanceOf()); - Assert.That(or.Right, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(or.Left, Is.InstanceOf()); + Assert.That(or.Right, Is.InstanceOf()); + }); } [Test] @@ -241,8 +298,11 @@ public class MarkdownParserTests Assert.That(result, Is.InstanceOf()); var or = (Or)result; - Assert.That(or.Left, Is.InstanceOf()); - Assert.That(or.Right, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(or.Left, Is.InstanceOf()); + Assert.That(or.Right, Is.InstanceOf()); + }); } [Test] @@ -252,8 +312,11 @@ public class MarkdownParserTests Assert.That(result, Is.InstanceOf()); var and = (And)result; - Assert.That(and.Left, Is.InstanceOf()); - Assert.That(and.Right, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(and.Left, Is.InstanceOf()); + Assert.That(and.Right, Is.InstanceOf()); + }); } [Test] @@ -263,12 +326,18 @@ public class MarkdownParserTests Assert.That(result, Is.InstanceOf()); var and = (And)result; - Assert.That(and.Left, Is.InstanceOf()); - Assert.That(and.Right, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(and.Left, Is.InstanceOf()); + Assert.That(and.Right, Is.InstanceOf()); + }); var or = (Or)and.Right; - Assert.That(or.Left, Is.InstanceOf()); - Assert.That(or.Right, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(or.Left, Is.InstanceOf()); + Assert.That(or.Right, Is.InstanceOf()); + }); } #endregion @@ -332,8 +401,11 @@ public class MarkdownParserTests { var success = Markdown.TryParse("x.Age = 25", out var expression); - Assert.That(success, Is.True); - Assert.That(expression, Is.Not.Null); + Assert.Multiple(() => + { + Assert.That(success, Is.True); + Assert.That(expression, Is.Not.Null); + }); Assert.That(expression, Is.InstanceOf()); } @@ -342,8 +414,11 @@ public class MarkdownParserTests { var success = Markdown.TryParse("@#$%", out var expression); - Assert.That(success, Is.False); - Assert.That(expression, Is.Null); + Assert.Multiple(() => + { + Assert.That(success, Is.False); + Assert.That(expression, Is.Null); + }); } #endregion @@ -364,10 +439,13 @@ public class MarkdownParserTests var greaterThan = (GreaterThan)and.Left; Assert.That(greaterThan.Left, Is.InstanceOf()); var userAge = (Property)greaterThan.Left; - Assert.That(userAge.PropertyName, Is.EqualTo("Age")); + Assert.Multiple(() => + { + Assert.That(userAge.PropertyName, Is.EqualTo("Age")); - // Right side: user.Status = "active" - Assert.That(and.Right, Is.InstanceOf()); + // Right side: user.Status = "active" + Assert.That(and.Right, Is.InstanceOf()); + }); var equal = (Equal)and.Right; Assert.That(equal.Left, Is.InstanceOf()); var userStatus = (Property)equal.Left; @@ -387,18 +465,27 @@ public class MarkdownParserTests Assert.That(result, Is.InstanceOf()); var or = (Or)result; - Assert.That(or.Left, Is.InstanceOf()); - Assert.That(or.Right, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(or.Left, Is.InstanceOf()); + Assert.That(or.Right, Is.InstanceOf()); + }); // Left AND: TotalCharges > 1000 AND Status = 'pending' var leftAnd = (And)or.Left; - Assert.That(leftAnd.Left, Is.InstanceOf()); - Assert.That(leftAnd.Right, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(leftAnd.Left, Is.InstanceOf()); + Assert.That(leftAnd.Right, Is.InstanceOf()); + }); // Right AND: Priority = 'urgent' AND ApprovedBy != '' var rightAnd = (And)or.Right; - Assert.That(rightAnd.Left, Is.InstanceOf()); - Assert.That(rightAnd.Right, Is.InstanceOf()); + Assert.Multiple(() => + { + Assert.That(rightAnd.Left, Is.InstanceOf()); + Assert.That(rightAnd.Right, Is.InstanceOf()); + }); } #endregion diff --git a/tests/Strata.SqlTools.Rules.Tests/RuleEngineTests.cs b/tests/Strata.SqlTools.Rules.Tests/RuleEngineTests.cs index 0440cf7..3a09dfd 100644 --- a/tests/Strata.SqlTools.Rules.Tests/RuleEngineTests.cs +++ b/tests/Strata.SqlTools.Rules.Tests/RuleEngineTests.cs @@ -609,9 +609,12 @@ public class RuleEngineTests var result1 = await engine.RunRules(ruleSet1, input); var result2 = await engine.RunRules(ruleSet2, input); - // Assert - Assert.That(result1, Is.False, "First rule set should fail"); - Assert.That(result2, Is.True, "Second rule set should pass"); + Assert.Multiple(() => + { + // Assert + Assert.That(result1, Is.False, "First rule set should fail"); + Assert.That(result2, Is.True, "Second rule set should pass"); + }); } #endregion diff --git a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/CTEColumnListTests.cs b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/CTEColumnListTests.cs index 6aa03d5..b046f45 100644 --- a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/CTEColumnListTests.cs +++ b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/CTEColumnListTests.cs @@ -20,9 +20,12 @@ public class CTEColumnListTests // Act & Assert Assert.That(withClause.ColumnList, Has.Count.EqualTo(3)); - Assert.That(withClause.ColumnList[0], Is.EqualTo("user_id")); - Assert.That(withClause.ColumnList[1], Is.EqualTo("user_name")); - Assert.That(withClause.ColumnList[2], Is.EqualTo("user_email")); + Assert.Multiple(() => + { + Assert.That(withClause.ColumnList[0], Is.EqualTo("user_id")); + Assert.That(withClause.ColumnList[1], Is.EqualTo("user_name")); + Assert.That(withClause.ColumnList[2], Is.EqualTo("user_email")); + }); } [Test] @@ -274,8 +277,11 @@ public class CTEColumnListTests // Assert Assert.That(sql, Contains.Substring("high_value_sales (sale_date_key, product_key, customer_key, units_sold, total_revenue)")); var paramKeys = params_all.Keys.ToList(); - Assert.That(paramKeys.Any(k => k.Contains("StartDateSk"))); - Assert.That(paramKeys.Any(k => k.Contains("MinRevenue"))); + Assert.Multiple(() => + { + Assert.That(paramKeys.Any(k => k.Contains("StartDateSk"))); + Assert.That(paramKeys.Any(k => k.Contains("MinRevenue"))); + }); } #endregion diff --git a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/CommentTests.cs b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/CommentTests.cs index e60411b..e632514 100644 --- a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/CommentTests.cs +++ b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/CommentTests.cs @@ -21,8 +21,11 @@ public class CommentTests // Assert Assert.That(query.SelectClause.Clause, Does.Contain("ID")); Assert.That(query.SelectClause.Clause, Does.Contain("NAME")); - Assert.That(query.SelectClause.Clause, Does.Contain("EMAIL")); - Assert.That(query.SelectClause.Comment, Does.Contain("-- This is a customer name")); + Assert.Multiple(() => + { + Assert.That(query.SelectClause.Clause, Does.Contain("EMAIL")); + Assert.That(query.SelectClause.Comment, Does.Contain("-- This is a customer name")); + }); } [Test] @@ -42,8 +45,11 @@ public class CommentTests // Assert Assert.That(query.SelectClause.Clause, Does.Contain("ID")); - Assert.That(query.SelectClause.Clause, Does.Contain("NAME")); - Assert.That(query.SelectClause.Comment, Does.Contain("/* Multi-line comment")); + Assert.Multiple(() => + { + Assert.That(query.SelectClause.Clause, Does.Contain("NAME")); + Assert.That(query.SelectClause.Comment, Does.Contain("/* Multi-line comment")); + }); Assert.That(query.SelectClause.Comment, Does.Contain("explaining the query */")); } @@ -64,11 +70,14 @@ public class CommentTests // Act var query = QueryBreakdown.Parse(sql); - // Assert - Assert.That(query.SelectClause.Comment, Does.Contain("-- Select specific columns")); - Assert.That(query.FromClause.Comment, Does.Contain("-- Main user table")); - Assert.That(query.WhereClause.Comment, Does.Contain("/* Active users only */")); - Assert.That(query.OrderByClause.Comment, Does.Contain("-- Sort by name")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Comment, Does.Contain("-- Select specific columns")); + Assert.That(query.FromClause.Comment, Does.Contain("-- Main user table")); + Assert.That(query.WhereClause.Comment, Does.Contain("/* Active users only */")); + Assert.That(query.OrderByClause.Comment, Does.Contain("-- Sort by name")); + }); } [Test] @@ -100,10 +109,13 @@ public class CommentTests // Act var query = QueryBreakdown.Parse(sql); - // Assert - Assert.That(query.SelectClause.Comment, Is.Null.Or.Empty); - Assert.That(query.FromClause.Comment, Is.Null.Or.Empty); - Assert.That(query.WhereClause.Comment, Is.Null.Or.Empty); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Comment, Is.Null.Or.Empty); + Assert.That(query.FromClause.Comment, Is.Null.Or.Empty); + Assert.That(query.WhereClause.Comment, Is.Null.Or.Empty); + }); } [Test] @@ -121,10 +133,13 @@ public class CommentTests // Act var cloned = (QueryBreakdown)original.Clone(); - // Assert - Assert.That(cloned.SelectClause.Comment, Is.EqualTo(original.SelectClause.Comment)); - Assert.That(cloned.FromClause.Comment, Is.EqualTo(original.FromClause.Comment)); - Assert.That(cloned.WhereClause.Comment, Is.EqualTo(original.WhereClause.Comment)); + Assert.Multiple(() => + { + // Assert + Assert.That(cloned.SelectClause.Comment, Is.EqualTo(original.SelectClause.Comment)); + Assert.That(cloned.FromClause.Comment, Is.EqualTo(original.FromClause.Comment)); + Assert.That(cloned.WhereClause.Comment, Is.EqualTo(original.WhereClause.Comment)); + }); } [Test] @@ -221,10 +236,16 @@ public class CommentTests // Assert Assert.That(comments, Has.Count.EqualTo(2)); - Assert.That(comments[0], Does.Contain("-- Single line")); - Assert.That(comments[1], Does.Contain("/* Multi")); - Assert.That(comments[1], Does.Contain("line */")); - Assert.That(cleanSql, Does.Not.Contain("-- Single line")); + Assert.Multiple(() => + { + Assert.That(comments[0], Does.Contain("-- Single line")); + Assert.That(comments[1], Does.Contain("/* Multi")); + }); + Assert.Multiple(() => + { + Assert.That(comments[1], Does.Contain("line */")); + Assert.That(cleanSql, Does.Not.Contain("-- Single line")); + }); Assert.That(cleanSql, Does.Not.Contain("/*")); } @@ -257,15 +278,21 @@ public class CommentTests Assert.That(query.SelectClause.Clause, Does.Contain("NAME")); Assert.That(query.SelectClause.Clause, Does.Contain("EMAIL")); Assert.That(query.SelectClause.Clause, Does.Not.Contain("--")); - Assert.That(query.SelectClause.Clause, Does.Not.Contain("/*")); + Assert.Multiple(() => + { + Assert.That(query.SelectClause.Clause, Does.Not.Contain("/*")); - Assert.That(query.SelectClause.Comment, Does.Contain("-- Primary key")); + Assert.That(query.SelectClause.Comment, Does.Contain("-- Primary key")); + }); Assert.That(query.SelectClause.Comment, Does.Contain("-- Customer name field")); - Assert.That(query.SelectClause.Comment, Does.Contain("/* Email address for notifications */")); + Assert.Multiple(() => + { + Assert.That(query.SelectClause.Comment, Does.Contain("/* Email address for notifications */")); - Assert.That(query.FromClause.Comment, Does.Contain("-- Main user table")); - Assert.That(query.WhereClause.Comment, Does.Contain("/* Filter for active users only */")); - Assert.That(query.OrderByClause.Comment, Does.Contain("-- Sort alphabetically")); + Assert.That(query.FromClause.Comment, Does.Contain("-- Main user table")); + Assert.That(query.WhereClause.Comment, Does.Contain("/* Filter for active users only */")); + Assert.That(query.OrderByClause.Comment, Does.Contain("-- Sort alphabetically")); + }); // Act - Generate SQL var regeneratedSql = query.GetSql(); @@ -325,8 +352,11 @@ public class CommentTests // Assert Assert.That(query.WhereClause.Comment, Does.Contain("-- Filter by status parameter")); - Assert.That(query.WhereClause.Comment, Does.Contain("-- Additional condition")); - Assert.That(query.Parameters, Contains.Key(":status")); + Assert.Multiple(() => + { + Assert.That(query.WhereClause.Comment, Does.Contain("-- Additional condition")); + Assert.That(query.Parameters, Contains.Key(":status")); + }); Assert.That(query.Parameters, Contains.Key(":start_date")); } diff --git a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownCollectionTests.cs b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownCollectionTests.cs index b929e34..a476455 100644 --- a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownCollectionTests.cs +++ b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownCollectionTests.cs @@ -188,8 +188,11 @@ public class QueryBreakdownCollectionTests // Assert Assert.That(summaries, Has.Count.EqualTo(2)); - Assert.That(summaries[0].UsesSemiStructuredData, Is.True); - Assert.That(summaries[1].UsesStageReference, Is.True); + Assert.Multiple(() => + { + Assert.That(summaries[0].UsesSemiStructuredData, Is.True); + Assert.That(summaries[1].UsesStageReference, Is.True); + }); } [Test] @@ -220,9 +223,12 @@ public class QueryBreakdownCollectionTests // Act _collection.AddParameterToAll("CompanyId", 99); - // Assert - Assert.That(_collection.QueryBreakdowns[0].Parameters["CompanyId"], Is.EqualTo(99)); - Assert.That(_collection.QueryBreakdowns[1].Parameters["CompanyId"], Is.EqualTo(99)); + Assert.Multiple(() => + { + // Assert + Assert.That(_collection.QueryBreakdowns[0].Parameters["CompanyId"], Is.EqualTo(99)); + Assert.That(_collection.QueryBreakdowns[1].Parameters["CompanyId"], Is.EqualTo(99)); + }); } [Test] diff --git a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownTests.cs b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownTests.cs index 849f135..090d8da 100644 --- a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownTests.cs +++ b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownTests.cs @@ -13,13 +13,16 @@ 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.That(queryBreakdown.GroupByClause.Clause, Is.EqualTo(string.Empty)); - Assert.That(queryBreakdown.HavingClause.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)); + Assert.That(queryBreakdown.GroupByClause.Clause, Is.EqualTo(string.Empty)); + Assert.That(queryBreakdown.HavingClause.Clause, Is.EqualTo(string.Empty)); + }); } [Test] @@ -32,9 +35,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] @@ -48,10 +54,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)); + }); } #endregion @@ -231,11 +240,14 @@ public class QueryBreakdownTests var innerParams = innerCte.ParameterList.Count(); var middleParams = middleCte.ParameterList.Count(); - // Assert - Each CTE maintains its own parameters - Assert.That(innerParams, Is.EqualTo(1)); - Assert.That(middleParams, Is.EqualTo(1)); - // SQL should contain both WITH clauses - Assert.That(sql, Does.Contain("WITH")); + Assert.Multiple(() => + { + // Assert - Each CTE maintains its own parameters + Assert.That(innerParams, Is.EqualTo(1)); + Assert.That(middleParams, Is.EqualTo(1)); + // SQL should contain both WITH clauses + Assert.That(sql, Does.Contain("WITH")); + }); Assert.That(sql, Does.Contain("RECENT_USERS")); Assert.That(sql, Does.Contain("FILTERED_USERS")); } @@ -289,8 +301,11 @@ public class QueryBreakdownTests // Assert - Verify WITH clause appears before main SELECT var withIndex = sql.IndexOf("WITH"); var mainSelectIndex = sql.LastIndexOf("SELECT"); - Assert.That(withIndex, Is.GreaterThan(-1)); - Assert.That(mainSelectIndex, Is.GreaterThan(-1)); + Assert.Multiple(() => + { + Assert.That(withIndex, Is.GreaterThan(-1)); + Assert.That(mainSelectIndex, Is.GreaterThan(-1)); + }); Assert.That(withIndex, Is.LessThan(mainSelectIndex)); // Assert - Verify CTE definition @@ -312,13 +327,19 @@ public class QueryBreakdownTests var sql = mainQuery.GetSql(); var withClause = mainQuery.WithClauses[0]; - // Assert: Verify WithClause properties - Assert.That(withClause.TableName, Is.EqualTo("SALES_TEAM")); - Assert.That(withClause.Query, Is.Not.Null); - Assert.That(withClause.Sql, Is.Not.Null); - Assert.That(withClause.Sql?.SelectClause?.Clause, Contains.Substring("ID, NAME")); - Assert.That(withClause.Sql?.FromClause?.Clause, Contains.Substring("EMPLOYEES")); - Assert.That(withClause.Sql?.WhereClause?.Clause, Contains.Substring("DEPARTMENT = 'Sales'")); + Assert.Multiple(() => + { + // Assert: Verify WithClause properties + Assert.That(withClause.TableName, Is.EqualTo("SALES_TEAM")); + Assert.That(withClause.Query, Is.Not.Null); + Assert.That(withClause.Sql, Is.Not.Null); + }); + Assert.Multiple(() => + { + Assert.That(withClause.Sql?.SelectClause?.Clause, Contains.Substring("ID, NAME")); + Assert.That(withClause.Sql?.FromClause?.Clause, Contains.Substring("EMPLOYEES")); + Assert.That(withClause.Sql?.WhereClause?.Clause, Contains.Substring("DEPARTMENT = 'Sales'")); + }); } [Test] @@ -334,9 +355,12 @@ public class QueryBreakdownTests var cte = new QueryBreakdown("ID, NAME", "SOURCE_TABLE"); query.AddWithClause("SOURCE_CTE", cte); - // Assert - Now using WITH clause - Assert.That(query.IsUsingWithClause, Is.True); - Assert.That(query.WithClauses, Has.Count.EqualTo(1)); + Assert.Multiple(() => + { + // Assert - Now using WITH clause + Assert.That(query.IsUsingWithClause, Is.True); + Assert.That(query.WithClauses, Has.Count.EqualTo(1)); + }); } #endregion @@ -357,8 +381,11 @@ 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.ContainsKey("@UserId") || merged.ContainsKey(":UserId"), Is.True); - Assert.That(merged.ContainsKey("@ActiveStatus") || merged.ContainsKey(":ActiveStatus"), Is.True); + Assert.Multiple(() => + { + Assert.That(merged.ContainsKey("@UserId") || merged.ContainsKey(":UserId"), Is.True); + Assert.That(merged.ContainsKey("@ActiveStatus") || merged.ContainsKey(":ActiveStatus"), Is.True); + }); } [Test] @@ -378,8 +405,11 @@ public class QueryBreakdownTests // Assert // Should have parameters from both CTE and main query 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] @@ -402,9 +432,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] @@ -452,9 +485,12 @@ public class QueryBreakdownTests // Assert - All parameters from all levels should be present var keys = merged.Keys.ToList(); - Assert.That(keys.Any(k => k.Contains("InnerParam"))); - Assert.That(keys.Any(k => k.Contains("MiddleParam"))); - Assert.That(keys.Any(k => k.Contains("MainParam"))); + Assert.Multiple(() => + { + Assert.That(keys.Any(k => k.Contains("InnerParam"))); + Assert.That(keys.Any(k => k.Contains("MiddleParam"))); + Assert.That(keys.Any(k => k.Contains("MainParam"))); + }); } [Test] @@ -480,10 +516,13 @@ public class QueryBreakdownTests var dateValues = merged.Values.OfType().Count(); var decimalValues = merged.Values.OfType().Count(); - Assert.That(intValues, Is.GreaterThan(0), "Should have at least one int value"); - Assert.That(stringValues, Is.GreaterThan(0), "Should have at least one string value"); - Assert.That(dateValues, Is.GreaterThan(0), "Should have at least one DateTime value"); - Assert.That(decimalValues, Is.GreaterThan(0), "Should have at least one decimal value"); + Assert.Multiple(() => + { + Assert.That(intValues, Is.GreaterThan(0), "Should have at least one int value"); + Assert.That(stringValues, Is.GreaterThan(0), "Should have at least one string value"); + Assert.That(dateValues, Is.GreaterThan(0), "Should have at least one DateTime value"); + Assert.That(decimalValues, Is.GreaterThan(0), "Should have at least one decimal value"); + }); } #endregion @@ -499,9 +538,12 @@ public class QueryBreakdownTests // Act var queryBreakdown = QueryBreakdown.Parse(sql, false); - // Assert - Assert.That(queryBreakdown.SelectClause.Clause?.Trim(), Does.Contain("ID, NAME")); - Assert.That(queryBreakdown.FromClause.Clause?.Trim(), Does.Contain("USERS")); + Assert.Multiple(() => + { + // Assert + Assert.That(queryBreakdown.SelectClause.Clause?.Trim(), Does.Contain("ID, NAME")); + Assert.That(queryBreakdown.FromClause.Clause?.Trim(), Does.Contain("USERS")); + }); } [Test] @@ -606,9 +648,12 @@ public class QueryBreakdownTests // Act var queryBreakdown = QueryBreakdown.Parse(sql, false); - // Assert - Assert.That(queryBreakdown.IsUsingWithClause, Is.True); - Assert.That(queryBreakdown.SelectClause.Clause?.Trim(), Does.Contain("P.*, PS.TOTAL_QTY")); + Assert.Multiple(() => + { + // Assert + Assert.That(queryBreakdown.IsUsingWithClause, Is.True); + Assert.That(queryBreakdown.SelectClause.Clause?.Trim(), Does.Contain("P.*, PS.TOTAL_QTY")); + }); } [Test] @@ -637,9 +682,12 @@ public class QueryBreakdownTests // Act var success = QueryBreakdown.TryParse(sql, out var queryBreakdown, false); - // Assert - Assert.That(success, Is.True); - Assert.That(queryBreakdown, Is.Not.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.True); + Assert.That(queryBreakdown, Is.Not.Null); + }); Assert.That(queryBreakdown, Is.InstanceOf()); } @@ -652,10 +700,13 @@ public class QueryBreakdownTests // Act var success = QueryBreakdown.TryParse(sql, out var queryBreakdown, out var error, false); - // Assert - Assert.That(success, Is.False); - Assert.That(queryBreakdown, Is.Null); - Assert.That(error, Is.Not.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.False); + Assert.That(queryBreakdown, Is.Null); + Assert.That(error, Is.Not.Null); + }); } #endregion @@ -672,9 +723,12 @@ public class QueryBreakdownTests queryBreakdown.AddParameter("UserId", 123); queryBreakdown.AddWhereClause("ACTIVE = 1"); - // Assert - Assert.That(queryBreakdown.Parameters, Does.ContainKey("@UserId")); - Assert.That(queryBreakdown.WhereClause.Clause, Does.Contain("ACTIVE = 1")); + Assert.Multiple(() => + { + // Assert + Assert.That(queryBreakdown.Parameters, Does.ContainKey("@UserId")); + Assert.That(queryBreakdown.WhereClause.Clause, Does.Contain("ACTIVE = 1")); + }); } [Test] @@ -687,9 +741,12 @@ public class QueryBreakdownTests // Act queryBreakdown.AddWithClause("ORDER_CTE", cte); - // Assert - Assert.That(queryBreakdown.WithClauses, Has.Count.EqualTo(1)); - Assert.That(queryBreakdown.IsUsingWithClause, Is.True); + Assert.Multiple(() => + { + // Assert + Assert.That(queryBreakdown.WithClauses, Has.Count.EqualTo(1)); + Assert.That(queryBreakdown.IsUsingWithClause, Is.True); + }); } [Test] @@ -740,8 +797,11 @@ public class QueryBreakdownTests Assert.That(sql, Does.Contain("WITH")); Assert.That(sql, Does.Contain("SALES_SUMMARY AS (")); Assert.That(sql, Does.Contain("ACTIVE_PRODUCTS AS (")); - Assert.That(sql, Does.Contain("LIMIT 100")); - Assert.That(mainQueryBreakdown.Parameters, Does.ContainKey(":minSales")); + Assert.Multiple(() => + { + Assert.That(sql, Does.Contain("LIMIT 100")); + Assert.That(mainQueryBreakdown.Parameters, Does.ContainKey(":minSales")); + }); Assert.That(mainQueryBreakdown.Parameters, Does.ContainKey(":startDate")); } @@ -762,8 +822,11 @@ public class QueryBreakdownTests // Assert Assert.That(sql, Does.Contain("WITH")); - Assert.That(sql, Does.Contain("MIDDLE_CTE AS (")); - Assert.That(mainQueryBreakdown.WithClauses, Has.Count.EqualTo(1)); + Assert.Multiple(() => + { + Assert.That(sql, Does.Contain("MIDDLE_CTE AS (")); + Assert.That(mainQueryBreakdown.WithClauses, Has.Count.EqualTo(1)); + }); } [Test] @@ -887,9 +950,12 @@ public class QueryBreakdownTests // Act var queryBreakdown = QueryBreakdown.Parse(sql, false); - // Assert - Assert.That(queryBreakdown.SelectClause.Clause, Does.Contain("F.VALUE")); - Assert.That(queryBreakdown.FromClause.Clause, Does.Contain("FLATTEN")); + Assert.Multiple(() => + { + // Assert + Assert.That(queryBreakdown.SelectClause.Clause, Does.Contain("F.VALUE")); + Assert.That(queryBreakdown.FromClause.Clause, Does.Contain("FLATTEN")); + }); } [Test] @@ -1148,9 +1214,12 @@ public class QueryBreakdownTests // Act var success = QueryBreakdown.TryParse(sql, out _, out var error, false); - // Assert - Assert.That(success, Is.False); - Assert.That(error, Is.Not.Null.And.Not.Empty); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.False); + Assert.That(error, Is.Not.Null.And.Not.Empty); + }); } [Test] @@ -1196,9 +1265,12 @@ public class QueryBreakdownTests // Act var queryBreakdown = QueryBreakdown.Parse(sql, false); - // Assert - Assert.That(queryBreakdown.SelectClause.Clause, Does.Contain("$1")); - Assert.That(queryBreakdown.FromClause.Clause, Does.Contain("@MY_STAGE")); + Assert.Multiple(() => + { + // Assert + Assert.That(queryBreakdown.SelectClause.Clause, Does.Contain("$1")); + Assert.That(queryBreakdown.FromClause.Clause, Does.Contain("@MY_STAGE")); + }); } [Test] @@ -1245,8 +1317,11 @@ public class QueryBreakdownTests Assert.That(sql, Does.Contain("SALES_SUMMARY AS (")); Assert.That(sql, Does.Contain("TOP_PRODUCTS AS (")); Assert.That(sql, Does.Contain("ROW_NUMBER()")); - Assert.That(sql, Does.Contain("LIMIT 100")); - Assert.That(mainQueryBreakdown.Parameters.Count, Is.GreaterThanOrEqualTo(2)); + Assert.Multiple(() => + { + Assert.That(sql, Does.Contain("LIMIT 100")); + Assert.That(mainQueryBreakdown.Parameters.Count, Is.GreaterThanOrEqualTo(2)); + }); } #endregion @@ -1265,9 +1340,12 @@ public class QueryBreakdownTests // Assert Assert.That(result, Is.Not.Null); Assert.That(result, Is.InstanceOf(), "Should return Snowflake QueryBreakdown instance"); - Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("Id, Name")); - Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("Users")); - Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("Active = 1")); + Assert.Multiple(() => + { + Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("Id, Name")); + Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("Users")); + Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("Active = 1")); + }); } [Test] @@ -1300,12 +1378,15 @@ public class QueryBreakdownTests // Assert Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("DepartmentId")); - Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("COUNT(*)")); - Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("Employees")); - Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("Active = 1")); - Assert.That(result.GroupByClause.Clause?.Trim(), Does.Contain("DepartmentId")); - Assert.That(result.HavingClause.Clause?.Trim(), Does.Contain("COUNT(*) > 5")); - Assert.That(result.OrderByClause.Clause?.Trim(), Does.Contain("EmployeeCount DESC")); + Assert.Multiple(() => + { + Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("COUNT(*)")); + Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("Employees")); + Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("Active = 1")); + Assert.That(result.GroupByClause.Clause?.Trim(), Does.Contain("DepartmentId")); + Assert.That(result.HavingClause.Clause?.Trim(), Does.Contain("COUNT(*) > 5")); + Assert.That(result.OrderByClause.Clause?.Trim(), Does.Contain("EmployeeCount DESC")); + }); } [Test] @@ -1343,11 +1424,17 @@ public class QueryBreakdownTests // Act var result = QueryBreakdown.Parse(tsqlQuery, isMicrosoftSql: true); - // Assert - Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("o.OrderId")); - Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("INNER JOIN")); - Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("LEFT JOIN")); - Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("OrderDate")); + Assert.Multiple(() => + { + // Assert + Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("o.OrderId")); + Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("INNER JOIN")); + }); + Assert.Multiple(() => + { + Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("LEFT JOIN")); + Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("OrderDate")); + }); } [Test] @@ -1361,9 +1448,12 @@ public class QueryBreakdownTests // Act var result = QueryBreakdown.Parse(tsqlQuery, isMicrosoftSql: true); - // Assert - Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("CustomerId, CustomerName")); - Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("IN")); + Assert.Multiple(() => + { + // Assert + Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("CustomerId, CustomerName")); + Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("IN")); + }); Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("SELECT")); } @@ -1376,9 +1466,12 @@ public class QueryBreakdownTests // Act var success = QueryBreakdown.TryParse(tsqlQuery, out var result, isMicrosoftSql: true); - // Assert - Assert.That(success, Is.True); - Assert.That(result, Is.Not.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.True); + Assert.That(result, Is.Not.Null); + }); Assert.That(result, Is.InstanceOf()); } @@ -1391,10 +1484,13 @@ public class QueryBreakdownTests // Act var success = QueryBreakdown.TryParse(invalidQuery, out var result, out var errorMessage, isMicrosoftSql: true); - // Assert - Assert.That(success, Is.False); - Assert.That(result, Is.Null); - Assert.That(errorMessage, Is.Not.Null.And.Not.Empty); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.False); + Assert.That(result, Is.Null); + Assert.That(errorMessage, Is.Not.Null.And.Not.Empty); + }); } [Test] @@ -1406,10 +1502,13 @@ public class QueryBreakdownTests // Act var result = QueryBreakdown.Parse(tsqlQuery, isMicrosoftSql: true); - // Assert - Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("[Order Id]")); - Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("[Order Details]")); - Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("[Active]")); + Assert.Multiple(() => + { + // Assert + Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("[Order Id]")); + Assert.That(result.FromClause.Clause?.Trim(), Does.Contain("[Order Details]")); + Assert.That(result.WhereClause.Clause?.Trim(), Does.Contain("[Active]")); + }); } [Test] @@ -1428,9 +1527,12 @@ public class QueryBreakdownTests // Act var result = QueryBreakdown.Parse(tsqlQuery, isMicrosoftSql: true); - // Assert - Assert.That(result.IsUsingWithClause, Is.True); - Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("DepartmentName")); + Assert.Multiple(() => + { + // Assert + Assert.That(result.IsUsingWithClause, Is.True); + Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("DepartmentName")); + }); } [Test] @@ -1452,8 +1554,11 @@ public class QueryBreakdownTests // Assert Assert.That(snowflakeSql, Does.Contain("WITH")); - Assert.That(snowflakeSql, Does.Contain("SELECT")); - Assert.That(result.IsUsingWithClause, Is.True, "Should have WITH clause parsed"); + Assert.Multiple(() => + { + Assert.That(snowflakeSql, Does.Contain("SELECT")); + Assert.That(result.IsUsingWithClause, Is.True, "Should have WITH clause parsed"); + }); // Note: WITH clause content is stored in WithClause property when parsed via isMicrosoftSql // The GetSql() will output it if WithClauses collection is populated or if we manually add it } @@ -1482,14 +1587,20 @@ public class QueryBreakdownTests // Assert - Verify parsing Assert.That(result, Is.InstanceOf()); - Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("YEAR")); - Assert.That(result.GroupByClause.Clause?.Trim(), Does.Contain("YEAR")); - Assert.That(result.HavingClause.Clause?.Trim(), Does.Contain("COUNT")); - Assert.That(result.Parameters, Does.ContainKey("@startDate")); - Assert.That(result.Parameters, Does.ContainKey("@endDate")); + Assert.Multiple(() => + { + Assert.That(result.SelectClause.Clause?.Trim(), Does.Contain("YEAR")); + Assert.That(result.GroupByClause.Clause?.Trim(), Does.Contain("YEAR")); + Assert.That(result.HavingClause.Clause?.Trim(), Does.Contain("COUNT")); + Assert.That(result.Parameters, Does.ContainKey("@startDate")); + }); + Assert.Multiple(() => + { + Assert.That(result.Parameters, Does.ContainKey("@endDate")); - // Assert - Verify Snowflake SQL generation - Assert.That(snowflakeSql, Does.Contain("SELECT")); + // Assert - Verify Snowflake SQL generation + Assert.That(snowflakeSql, Does.Contain("SELECT")); + }); Assert.That(snowflakeSql, Does.Contain("FROM")); Assert.That(snowflakeSql, Does.Contain("WHERE")); Assert.That(snowflakeSql, Does.Contain("GROUP BY")); @@ -1510,9 +1621,12 @@ public class QueryBreakdownTests result.AddWithClause("ProductSummary", cteQuery); var snowflakeSql = result.GetSql(); - // Assert - Assert.That(result.WithClauses, Has.Count.EqualTo(1)); - Assert.That(snowflakeSql, Does.Contain("WITH")); + Assert.Multiple(() => + { + // Assert + Assert.That(result.WithClauses, Has.Count.EqualTo(1)); + Assert.That(snowflakeSql, Does.Contain("WITH")); + }); Assert.That(snowflakeSql, Does.Contain("ProductSummary AS (")); } @@ -1528,9 +1642,12 @@ public class QueryBreakdownTests // Assert Assert.That(clone, Is.InstanceOf()); - Assert.That(clone.SelectClause.Clause, Is.EqualTo(original.SelectClause.Clause)); - Assert.That(clone.FromClause.Clause, Is.EqualTo(original.FromClause.Clause)); - Assert.That(clone.WhereClause.Clause, Is.EqualTo(original.WhereClause.Clause)); + Assert.Multiple(() => + { + Assert.That(clone.SelectClause.Clause, Is.EqualTo(original.SelectClause.Clause)); + Assert.That(clone.FromClause.Clause, Is.EqualTo(original.FromClause.Clause)); + Assert.That(clone.WhereClause.Clause, Is.EqualTo(original.WhereClause.Clause)); + }); } #endregion @@ -1608,9 +1725,12 @@ public class QueryBreakdownTests // Act query.AddSelectExpression(expr, "/* Primary key */"); - // Assert - Assert.That(query.SelectClause.Clause, Is.EqualTo("CUSTOMERS.CUSTOMER_ID")); - Assert.That(query.SelectClause.Comment, Is.EqualTo("/* Primary key */")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Clause, Is.EqualTo("CUSTOMERS.CUSTOMER_ID")); + Assert.That(query.SelectClause.Comment, Is.EqualTo("/* Primary key */")); + }); } [Test] @@ -1888,12 +2008,18 @@ public class QueryBreakdownTests // Act - Use Snowflake :param syntax query.AddWhereClause("USER_ID = :UserId AND STATUS = :Status", false); - // Assert - Assert.That(query.WhereClause.Clause, Is.EqualTo("USER_ID = :UserId AND STATUS = :Status")); - Assert.That(query.Parameters, Does.ContainKey(":UserId")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.WhereClause.Clause, Is.EqualTo("USER_ID = :UserId AND STATUS = :Status")); + Assert.That(query.Parameters, Does.ContainKey(":UserId")); + }); Assert.That(query.Parameters, Does.ContainKey(":Status")); - Assert.That(query.Parameters[":UserId"], Is.Null); - Assert.That(query.Parameters[":Status"], Is.Null); + Assert.Multiple(() => + { + Assert.That(query.Parameters[":UserId"], Is.Null); + Assert.That(query.Parameters[":Status"], Is.Null); + }); } [Test] @@ -1905,9 +2031,12 @@ public class QueryBreakdownTests // Act - Use Microsoft @param syntax with isMicrosoftSql=true query.AddWhereClause("USER_ID = @UserId AND STATUS = @Status", "and", true); - // Assert - Assert.That(query.WhereClause.Clause, Is.EqualTo("USER_ID = @UserId AND STATUS = @Status")); - Assert.That(query.Parameters, Does.ContainKey("@UserId")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.WhereClause.Clause, Is.EqualTo("USER_ID = @UserId AND STATUS = @Status")); + Assert.That(query.Parameters, Does.ContainKey("@UserId")); + }); Assert.That(query.Parameters, Does.ContainKey("@Status")); } diff --git a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/RecursiveCTETests.cs b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/RecursiveCTETests.cs index 54a8830..6cb17f2 100644 --- a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/RecursiveCTETests.cs +++ b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/RecursiveCTETests.cs @@ -33,9 +33,12 @@ public class RecursiveCTETests var isRecursive = withClause.IsRecursive; var hasRecursiveQuery = withClause.RecursiveQuery != null; - // Assert - Assert.That(isRecursive, Is.True); - Assert.That(hasRecursiveQuery, Is.True); + Assert.Multiple(() => + { + // Assert + Assert.That(isRecursive, Is.True); + Assert.That(hasRecursiveQuery, Is.True); + }); } [Test] @@ -143,10 +146,13 @@ public class RecursiveCTETests // Assert var keys = merged.Keys.ToList(); - Assert.That(keys.Any(k => k.Contains("AnchorStatus")), "Should include anchor query parameters"); - Assert.That(keys.Any(k => k.Contains("RecursiveLevel")), "Should include recursive query parameters"); - Assert.That(keys.Any(k => k.Contains("RecursiveStatus")), "Should include recurring query parameters"); - Assert.That(keys.Any(k => k.Contains("MainLimit")), "Should include main query parameters"); + Assert.Multiple(() => + { + Assert.That(keys.Any(k => k.Contains("AnchorStatus")), "Should include anchor query parameters"); + Assert.That(keys.Any(k => k.Contains("RecursiveLevel")), "Should include recursive query parameters"); + Assert.That(keys.Any(k => k.Contains("RecursiveStatus")), "Should include recurring query parameters"); + Assert.That(keys.Any(k => k.Contains("MainLimit")), "Should include main query parameters"); + }); } [Test] @@ -176,8 +182,11 @@ public class RecursiveCTETests // Assert // Snowflake stores parameters with both @ and : formats var statusKey = merged.Keys.FirstOrDefault(k => k.Contains("Status") && (k.StartsWith('@') || k.StartsWith(':'))); - Assert.That(statusKey, Is.Not.Null); - Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence"); + Assert.Multiple(() => + { + Assert.That(statusKey, Is.Not.Null); + Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence"); + }); } #endregion diff --git a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/StatementExpressionParserTests.cs b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/StatementExpressionParserTests.cs index 4f23d15..82e1d2b 100644 --- a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/StatementExpressionParserTests.cs +++ b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/StatementExpressionParserTests.cs @@ -34,8 +34,11 @@ public class StatementExpressionParserTests // Assert Assert.That(result, Is.Not.Null); - Assert.That(result, Is.InstanceOf()); - Assert.That(((NumberLiteralExpression)result).Value, Is.EqualTo(42)); + Assert.Multiple(() => + { + Assert.That(result, Is.InstanceOf()); + Assert.That(((NumberLiteralExpression)result).Value, Is.EqualTo(42)); + }); } [Test] @@ -49,8 +52,11 @@ public class StatementExpressionParserTests // Assert Assert.That(result, Is.Not.Null); - Assert.That(result, Is.InstanceOf()); - Assert.That(((NumberLiteralExpression)result).Value, Is.EqualTo(3.14m)); + Assert.Multiple(() => + { + Assert.That(result, Is.InstanceOf()); + Assert.That(((NumberLiteralExpression)result).Value, Is.EqualTo(3.14m)); + }); } [Test] @@ -64,8 +70,11 @@ public class StatementExpressionParserTests // Assert Assert.That(result, Is.Not.Null); - Assert.That(result, Is.InstanceOf()); - Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("CUSTOMER_ID")); + Assert.Multiple(() => + { + Assert.That(result, Is.InstanceOf()); + Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("CUSTOMER_ID")); + }); } [Test] @@ -79,8 +88,11 @@ public class StatementExpressionParserTests // Assert Assert.That(result, Is.Not.Null); - Assert.That(result, Is.InstanceOf()); - Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("CUSTOMER_ID")); + Assert.Multiple(() => + { + Assert.That(result, Is.InstanceOf()); + Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("CUSTOMER_ID")); + }); } #endregion @@ -232,8 +244,11 @@ public class StatementExpressionParserTests // Assert Assert.That(result, Is.Not.Null); - Assert.That(result, Is.InstanceOf()); - Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("ORDER_TOTAL")); + Assert.Multiple(() => + { + Assert.That(result, Is.InstanceOf()); + Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("ORDER_TOTAL")); + }); } [Test] @@ -247,8 +262,11 @@ public class StatementExpressionParserTests // Assert Assert.That(result, Is.Not.Null); - Assert.That(result, Is.InstanceOf()); - Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("NET_REVENUE_USD_2024")); + Assert.Multiple(() => + { + Assert.That(result, Is.InstanceOf()); + Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("NET_REVENUE_USD_2024")); + }); } [Test] @@ -368,9 +386,12 @@ public class StatementExpressionParserTests // Act var success = _parser.TryParse(sql, out var result); - // Assert - Assert.That(success, Is.False); - Assert.That(result, Is.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.False); + Assert.That(result, Is.Null); + }); } #endregion diff --git a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/StatementReaderTests.cs b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/StatementReaderTests.cs index 57e29ac..519d4ce 100644 --- a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/StatementReaderTests.cs +++ b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/StatementReaderTests.cs @@ -23,9 +23,12 @@ public class StatementReaderTests // Assert Assert.That(tokens, Is.Not.Empty); - Assert.That(tokens[0].Type, Is.EqualTo(TokenType.LeftParenthesis)); - Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Number)); - Assert.That(tokens[1].Value, Is.EqualTo("1")); + Assert.Multiple(() => + { + Assert.That(tokens[0].Type, Is.EqualTo(TokenType.LeftParenthesis)); + Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Number)); + Assert.That(tokens[1].Value, Is.EqualTo("1")); + }); } [Test] @@ -44,14 +47,17 @@ public class StatementReaderTests // Assert Assert.That(tokens, Has.Count.EqualTo(5)); // "COLUMN_1" + "COLUMN_2" * 2 - Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier)); - Assert.That(tokens[0].Value, Is.EqualTo("COLUMN_1")); - Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus)); - Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier)); - Assert.That(tokens[2].Value, Is.EqualTo("COLUMN_2")); - Assert.That(tokens[3].Type, Is.EqualTo(TokenType.Multiply)); - Assert.That(tokens[4].Type, Is.EqualTo(TokenType.Number)); - Assert.That(tokens[4].Value, Is.EqualTo("2")); + Assert.Multiple(() => + { + Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier)); + Assert.That(tokens[0].Value, Is.EqualTo("COLUMN_1")); + Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus)); + Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier)); + Assert.That(tokens[2].Value, Is.EqualTo("COLUMN_2")); + Assert.That(tokens[3].Type, Is.EqualTo(TokenType.Multiply)); + Assert.That(tokens[4].Type, Is.EqualTo(TokenType.Number)); + Assert.That(tokens[4].Value, Is.EqualTo("2")); + }); } [Test] @@ -70,14 +76,17 @@ public class StatementReaderTests // Assert Assert.That(tokens, Has.Count.EqualTo(5)); - Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier)); - Assert.That(tokens[0].Value, Is.EqualTo("REVENUE")); - Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus)); - Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier)); - Assert.That(tokens[2].Value, Is.EqualTo("COST")); - Assert.That(tokens[3].Type, Is.EqualTo(TokenType.Minus)); - Assert.That(tokens[4].Type, Is.EqualTo(TokenType.String)); - Assert.That(tokens[4].Value, Is.EqualTo("PROFIT")); + Assert.Multiple(() => + { + Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier)); + Assert.That(tokens[0].Value, Is.EqualTo("REVENUE")); + Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus)); + Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier)); + Assert.That(tokens[2].Value, Is.EqualTo("COST")); + Assert.That(tokens[3].Type, Is.EqualTo(TokenType.Minus)); + Assert.That(tokens[4].Type, Is.EqualTo(TokenType.String)); + Assert.That(tokens[4].Value, Is.EqualTo("PROFIT")); + }); } [Test] @@ -96,11 +105,14 @@ public class StatementReaderTests // Assert Assert.That(tokens, Is.Not.Empty); - Assert.That(tokens[0].Type, Is.EqualTo(TokenType.FunctionStart)); - Assert.That(tokens[0].Value, Is.EqualTo("SUM")); - Assert.That(tokens[1].Type, Is.EqualTo(TokenType.ColumnIdentifier)); - Assert.That(tokens[1].Value, Is.EqualTo("TOTAL_AMOUNT")); - Assert.That(tokens[2].Type, Is.EqualTo(TokenType.FunctionEnd)); + Assert.Multiple(() => + { + Assert.That(tokens[0].Type, Is.EqualTo(TokenType.FunctionStart)); + Assert.That(tokens[0].Value, Is.EqualTo("SUM")); + Assert.That(tokens[1].Type, Is.EqualTo(TokenType.ColumnIdentifier)); + Assert.That(tokens[1].Value, Is.EqualTo("TOTAL_AMOUNT")); + Assert.That(tokens[2].Type, Is.EqualTo(TokenType.FunctionEnd)); + }); } [Test] @@ -119,14 +131,17 @@ public class StatementReaderTests // Assert Assert.That(tokens, Has.Count.EqualTo(5)); - Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier)); - Assert.That(tokens[0].Value, Is.EqualTo("3_REVENUE")); - Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus)); - Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier)); - Assert.That(tokens[2].Value, Is.EqualTo("4_COST")); - Assert.That(tokens[3].Type, Is.EqualTo(TokenType.Minus)); - Assert.That(tokens[4].Type, Is.EqualTo(TokenType.ColumnIdentifier)); - Assert.That(tokens[4].Value, Is.EqualTo("5_PROFIT")); + Assert.Multiple(() => + { + Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier)); + Assert.That(tokens[0].Value, Is.EqualTo("3_REVENUE")); + Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus)); + Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier)); + Assert.That(tokens[2].Value, Is.EqualTo("4_COST")); + Assert.That(tokens[3].Type, Is.EqualTo(TokenType.Minus)); + Assert.That(tokens[4].Type, Is.EqualTo(TokenType.ColumnIdentifier)); + Assert.That(tokens[4].Value, Is.EqualTo("5_PROFIT")); + }); } [Test] @@ -145,11 +160,14 @@ public class StatementReaderTests // Assert Assert.That(tokens, Has.Count.EqualTo(3)); - Assert.That(tokens[0].Type, Is.EqualTo(TokenType.Number)); - Assert.That(tokens[0].Value, Is.EqualTo("123.45")); - Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus)); - Assert.That(tokens[2].Type, Is.EqualTo(TokenType.Number)); - Assert.That(tokens[2].Value, Is.EqualTo("67.89")); + Assert.Multiple(() => + { + Assert.That(tokens[0].Type, Is.EqualTo(TokenType.Number)); + Assert.That(tokens[0].Value, Is.EqualTo("123.45")); + Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus)); + Assert.That(tokens[2].Type, Is.EqualTo(TokenType.Number)); + Assert.That(tokens[2].Value, Is.EqualTo("67.89")); + }); } [Test] @@ -168,11 +186,14 @@ public class StatementReaderTests // Assert Assert.That(tokens, Has.Count.EqualTo(3)); - Assert.That(tokens[0].Type, Is.EqualTo(TokenType.String)); - Assert.That(tokens[0].Value, Is.EqualTo("REVENUE")); - Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus)); - Assert.That(tokens[2].Type, Is.EqualTo(TokenType.String)); - Assert.That(tokens[2].Value, Is.EqualTo("COST")); + Assert.Multiple(() => + { + Assert.That(tokens[0].Type, Is.EqualTo(TokenType.String)); + Assert.That(tokens[0].Value, Is.EqualTo("REVENUE")); + Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus)); + Assert.That(tokens[2].Type, Is.EqualTo(TokenType.String)); + Assert.That(tokens[2].Value, Is.EqualTo("COST")); + }); } [Test] @@ -217,11 +238,14 @@ public class StatementReaderTests // Assert Assert.That(tokens, Is.Not.Empty); - Assert.That(tokens[0].Type, Is.EqualTo(TokenType.FunctionStart)); - Assert.That(tokens[0].Value, Is.EqualTo("SUM")); - Assert.That(tokens[1].Type, Is.EqualTo(TokenType.FunctionStart)); - Assert.That(tokens[1].Value, Is.EqualTo("AVG")); - Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier)); - Assert.That(tokens[2].Value, Is.EqualTo("REVENUE")); + Assert.Multiple(() => + { + Assert.That(tokens[0].Type, Is.EqualTo(TokenType.FunctionStart)); + Assert.That(tokens[0].Value, Is.EqualTo("SUM")); + Assert.That(tokens[1].Type, Is.EqualTo(TokenType.FunctionStart)); + Assert.That(tokens[1].Value, Is.EqualTo("AVG")); + Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier)); + Assert.That(tokens[2].Value, Is.EqualTo("REVENUE")); + }); } } diff --git a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/WithClauseTests.cs b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/WithClauseTests.cs index fabee79..44e87e2 100644 --- a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/WithClauseTests.cs +++ b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/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 >= :start_date")); + 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 >= :start_date")); - // 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 diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/Exceptions/ExceptionHandlingTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/Exceptions/ExceptionHandlingTests.cs index 11b1661..03819cc 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/Exceptions/ExceptionHandlingTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/Exceptions/ExceptionHandlingTests.cs @@ -22,11 +22,14 @@ public class ExceptionHandlingTests // Act var exception = new SqlParseException(message, sql, position); - // Assert - Assert.That(exception.Message, Does.Contain(message)); - Assert.That(exception.Sql, Is.EqualTo(sql)); - Assert.That(exception.Position, Is.EqualTo(position)); - Assert.That(exception.NearText, Is.Not.Empty); + Assert.Multiple(() => + { + // Assert + Assert.That(exception.Message, Does.Contain(message)); + Assert.That(exception.Sql, Is.EqualTo(sql)); + Assert.That(exception.Position, Is.EqualTo(position)); + Assert.That(exception.NearText, Is.Not.Empty); + }); } [Test] @@ -57,10 +60,13 @@ public class ExceptionHandlingTests // Act var exception = new SqlParseException(message, sql!, position); - // Assert - Assert.That(exception.Message, Does.Contain("SQL is null")); - Assert.That(exception.Sql, Is.EqualTo(string.Empty)); - Assert.That(exception.NearText, Is.EqualTo(string.Empty)); + Assert.Multiple(() => + { + // Assert + Assert.That(exception.Message, Does.Contain("SQL is null")); + Assert.That(exception.Sql, Is.EqualTo(string.Empty)); + Assert.That(exception.NearText, Is.EqualTo(string.Empty)); + }); } [Test] @@ -90,9 +96,12 @@ public class ExceptionHandlingTests // Act var exception = new SqlParseException(message, sql, position, innerException); - // Assert - Assert.That(exception.InnerException, Is.EqualTo(innerException)); - Assert.That(exception.Message, Does.Contain("Parse failed")); + Assert.Multiple(() => + { + // Assert + Assert.That(exception.InnerException, Is.EqualTo(innerException)); + Assert.That(exception.Message, Does.Contain("Parse failed")); + }); } #endregion @@ -110,10 +119,13 @@ public class ExceptionHandlingTests // Act var exception = new CteValidationException(message, cteName, validationRule); - // Assert - Assert.That(exception.Message, Does.Contain(message)); - Assert.That(exception.CteName, Is.EqualTo(cteName)); - Assert.That(exception.ValidationRule, Is.EqualTo(validationRule)); + Assert.Multiple(() => + { + // Assert + Assert.That(exception.Message, Does.Contain(message)); + Assert.That(exception.CteName, Is.EqualTo(cteName)); + Assert.That(exception.ValidationRule, Is.EqualTo(validationRule)); + }); } [Test] @@ -141,9 +153,12 @@ public class ExceptionHandlingTests // Act var exception = new CteValidationException(message, "my_cte", validationRule); - // Assert - Assert.That(exception.ValidationRule, Is.EqualTo(validationRule)); - Assert.That(exception.Message, Does.Contain("Validation failed")); + Assert.Multiple(() => + { + // Assert + Assert.That(exception.ValidationRule, Is.EqualTo(validationRule)); + Assert.That(exception.Message, Does.Contain("Validation failed")); + }); } [Test] @@ -204,8 +219,11 @@ public class ExceptionHandlingTests // Act & Assert var exception = Assert.Throws(() => QueryBreakdown.Parse(sql)); - Assert.That(exception!.Sql, Is.EqualTo(sql)); - Assert.That(exception.Message, Does.Contain("Failed to parse")); + Assert.Multiple(() => + { + Assert.That(exception!.Sql, Is.EqualTo(sql)); + Assert.That(exception.Message, Does.Contain("Failed to parse")); + }); } [Test] @@ -274,8 +292,11 @@ public class ExceptionHandlingTests // Act & Assert var exception = Assert.Throws(() => query.AddWithClause("test_cte", (QueryBreakdown)null!)); - Assert.That(exception!.ValidationRule, Is.EqualTo("QueryRequired")); - Assert.That(exception.CteName, Is.EqualTo("test_cte")); + Assert.Multiple(() => + { + Assert.That(exception!.ValidationRule, Is.EqualTo("QueryRequired")); + Assert.That(exception.CteName, Is.EqualTo("test_cte")); + }); } [Test] @@ -291,8 +312,11 @@ public class ExceptionHandlingTests // Act & Assert var exception = Assert.Throws(() => query.AddWithClause("my_cte", cte2)); - Assert.That(exception!.ValidationRule, Is.EqualTo("DuplicateCteName")); - Assert.That(exception.Message, Does.Contain("already exists")); + Assert.Multiple(() => + { + Assert.That(exception!.ValidationRule, Is.EqualTo("DuplicateCteName")); + Assert.That(exception.Message, Does.Contain("already exists")); + }); } [Test] @@ -344,8 +368,11 @@ public class ExceptionHandlingTests // Act & Assert var exception = Assert.Throws(() => query.AddWithClause("my_cte", "INVALID SQL")); - Assert.That(exception!.Message, Does.Contain("my_cte")); - Assert.That(exception.Sql, Is.EqualTo("INVALID SQL")); + Assert.Multiple(() => + { + Assert.That(exception!.Message, Does.Contain("my_cte")); + Assert.That(exception.Sql, Is.EqualTo("INVALID SQL")); + }); } [Test] @@ -374,8 +401,11 @@ public class ExceptionHandlingTests // Act & Assert var exception = Assert.Throws(() => query.AddWithClause(withClause)); - Assert.That(exception!.ValidationRule, Is.EqualTo("QueryRequired")); - Assert.That(exception.Message, Does.Contain("Query or Sql")); + Assert.Multiple(() => + { + Assert.That(exception!.ValidationRule, Is.EqualTo("QueryRequired")); + Assert.That(exception.Message, Does.Contain("Query or Sql")); + }); } [Test] @@ -435,9 +465,12 @@ public class ExceptionHandlingTests // Act var exception = new SqlParseException("Syntax error", sql, position); - // Assert - Assert.That(exception.NearText, Does.Contain("status")); - Assert.That(exception.Message, Does.Contain("Near:")); + Assert.Multiple(() => + { + // Assert + Assert.That(exception.NearText, Does.Contain("status")); + Assert.That(exception.Message, Does.Contain("Near:")); + }); } #endregion diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/BooleanExpressionTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/BooleanExpressionTests.cs index 48f4604..b487c25 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/BooleanExpressionTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/BooleanExpressionTests.cs @@ -24,8 +24,11 @@ public class BooleanExpressionTests : ExpressionTestsBase // Assert Assert.That(firstResult, Is.Not.SameAs(BooleanExpression.False)); - Assert.That(firstResult, Is.AssignableTo()); - Assert.That(secondResult, Is.Not.SameAs(BooleanExpression.False)); + Assert.Multiple(() => + { + Assert.That(firstResult, Is.AssignableTo()); + Assert.That(secondResult, Is.Not.SameAs(BooleanExpression.False)); + }); Assert.That(secondResult, Is.TypeOf()); } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/GenericColumnExpressionTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/GenericColumnExpressionTests.cs index db5e141..36947a4 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/GenericColumnExpressionTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/GenericColumnExpressionTests.cs @@ -35,11 +35,9 @@ public class GenericColumnExpressionTests : ExpressionTestsBase Assertions = result => { var results = (Dictionary)result; - Assert.That(results["priceWithTax"], Does.Contain("Price")); - Assert.That(results["priceWithTax"], Does.Contain("1.1")); - Assert.That(results["priceWithFee"], Does.Contain("Price")); - Assert.That(results["priceWithFee"], Does.Contain("10")); - Assert.That(results["revenue"], Does.Contain("Quantity")); + Assert.That(results["priceWithTax"], Does.Contain("Price")); Assert.Multiple(() => { Assert.That(results["priceWithTax"], Does.Contain("1.1")); + Assert.That(results["priceWithFee"], Does.Contain("Price")); }); Assert.Multiple(() => { Assert.That(results["priceWithFee"], Does.Contain("10")); + Assert.That(results["revenue"], Does.Contain("Quantity")); }); Assert.That(results["revenue"], Does.Contain("Price")); return true; } @@ -151,9 +149,8 @@ public class GenericColumnExpressionTests : ExpressionTestsBase }, Assertions = result => { - var results = (Dictionary)result; - Assert.That(results["customerResult"], Does.Contain("CustomerID")); - Assert.That(results["orderResult"], Does.Contain("OrderDate")); + var results = (Dictionary)result; Assert.Multiple(() => { Assert.That(results["customerResult"], Does.Contain("CustomerID")); + Assert.That(results["orderResult"], Does.Contain("OrderDate")); }); return true; } }, @@ -182,9 +179,8 @@ public class GenericColumnExpressionTests : ExpressionTestsBase Assertions = result => { var results = (Dictionary)result; - Assert.That(results["lowerBound"], Does.Contain("UnitPrice")); - Assert.That(results["lowerBound"], Does.Contain("MinPrice")); - Assert.That(results["upperBound"], Does.Contain("UnitPrice")); + Assert.That(results["lowerBound"], Does.Contain("UnitPrice")); Assert.Multiple(() => { Assert.That(results["lowerBound"], Does.Contain("MinPrice")); + Assert.That(results["upperBound"], Does.Contain("UnitPrice")); }); Assert.That(results["upperBound"], Does.Contain("MaxPrice")); return true; } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/Extensions/QueryBreakdownExtensionsTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/Extensions/QueryBreakdownExtensionsTests.cs index 3c28460..da0f2ad 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/Extensions/QueryBreakdownExtensionsTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/Extensions/QueryBreakdownExtensionsTests.cs @@ -17,9 +17,12 @@ public class QueryBreakdownExtensionsTests // Act var result = query.Select("id, name"); - // Assert - Assert.That(result, Is.SameAs(query)); - Assert.That(query.SelectClause.Clause, Is.EqualTo("id, name")); + Assert.Multiple(() => + { + // Assert + Assert.That(result, Is.SameAs(query)); + Assert.That(query.SelectClause.Clause, Is.EqualTo("id, name")); + }); } [Test] @@ -31,9 +34,12 @@ public class QueryBreakdownExtensionsTests // Act var result = query.From("users"); - // Assert - Assert.That(result, Is.SameAs(query)); - Assert.That(query.FromClause.Clause, Is.EqualTo("users")); + Assert.Multiple(() => + { + // Assert + Assert.That(result, Is.SameAs(query)); + Assert.That(query.FromClause.Clause, Is.EqualTo("users")); + }); } [Test] @@ -45,9 +51,12 @@ public class QueryBreakdownExtensionsTests // Act var result = query.Where("active = 1"); - // Assert - Assert.That(result, Is.SameAs(query)); - Assert.That(query.WhereClause.Clause, Is.EqualTo("active = 1")); + Assert.Multiple(() => + { + // Assert + Assert.That(result, Is.SameAs(query)); + Assert.That(query.WhereClause.Clause, Is.EqualTo("active = 1")); + }); } [Test] @@ -59,9 +68,12 @@ public class QueryBreakdownExtensionsTests // Act var result = query.GroupBy("department"); - // Assert - Assert.That(result, Is.SameAs(query)); - Assert.That(query.GroupByClause.Clause, Is.EqualTo("department")); + Assert.Multiple(() => + { + // Assert + Assert.That(result, Is.SameAs(query)); + Assert.That(query.GroupByClause.Clause, Is.EqualTo("department")); + }); } [Test] @@ -73,9 +85,12 @@ public class QueryBreakdownExtensionsTests // Act var result = query.Having("COUNT(*) > 5"); - // Assert - Assert.That(result, Is.SameAs(query)); - Assert.That(query.HavingClause.Clause, Is.EqualTo("COUNT(*) > 5")); + Assert.Multiple(() => + { + // Assert + Assert.That(result, Is.SameAs(query)); + Assert.That(query.HavingClause.Clause, Is.EqualTo("COUNT(*) > 5")); + }); } [Test] @@ -87,9 +102,12 @@ public class QueryBreakdownExtensionsTests // Act var result = query.OrderBy("name ASC"); - // Assert - Assert.That(result, Is.SameAs(query)); - Assert.That(query.OrderByClause.Clause, Is.EqualTo("name ASC")); + Assert.Multiple(() => + { + // Assert + Assert.That(result, Is.SameAs(query)); + Assert.That(query.OrderByClause.Clause, Is.EqualTo("name ASC")); + }); } [Test] @@ -101,9 +119,12 @@ public class QueryBreakdownExtensionsTests // Act var result = query.AddWhere("AND age > 18"); - // Assert - Assert.That(result, Is.SameAs(query)); - Assert.That(query.WhereClause.Clause, Does.Contain("active = 1")); + Assert.Multiple(() => + { + // Assert + Assert.That(result, Is.SameAs(query)); + Assert.That(query.WhereClause.Clause, Does.Contain("active = 1")); + }); Assert.That(query.WhereClause.Clause, Does.Contain("AND age > 18")); } @@ -120,10 +141,13 @@ public class QueryBreakdownExtensionsTests .From("users") .Where("active = 1"); - // 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.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")); + }); } [Test] @@ -138,13 +162,16 @@ public class QueryBreakdownExtensionsTests .Having("COUNT(*) > 5") .OrderBy("employee_count DESC"); - // Assert - Assert.That(query.SelectClause.Clause, Is.EqualTo("department, COUNT(*) as employee_count")); - Assert.That(query.FromClause.Clause, Is.EqualTo("employees")); - Assert.That(query.WhereClause.Clause, Is.EqualTo("salary > 50000")); - Assert.That(query.GroupByClause.Clause, Is.EqualTo("department")); - Assert.That(query.HavingClause.Clause, Is.EqualTo("COUNT(*) > 5")); - Assert.That(query.OrderByClause.Clause, Is.EqualTo("employee_count DESC")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Clause, Is.EqualTo("department, COUNT(*) as employee_count")); + Assert.That(query.FromClause.Clause, Is.EqualTo("employees")); + Assert.That(query.WhereClause.Clause, Is.EqualTo("salary > 50000")); + Assert.That(query.GroupByClause.Clause, Is.EqualTo("department")); + Assert.That(query.HavingClause.Clause, Is.EqualTo("COUNT(*) > 5")); + Assert.That(query.OrderByClause.Clause, Is.EqualTo("employee_count DESC")); + }); } [Test] @@ -186,12 +213,18 @@ public class QueryBreakdownExtensionsTests .Select("*") .From("active_users"); - // Assert - Assert.That(query.IsUsingWithClause, Is.True); - Assert.That(query.WithClauses, Has.Count.EqualTo(1)); - Assert.That(query.WithClauses[0].TableName, Is.EqualTo("active_users")); - Assert.That(query.SelectClause.Clause, Is.EqualTo("*")); - Assert.That(query.FromClause.Clause, Is.EqualTo("active_users")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.IsUsingWithClause, Is.True); + Assert.That(query.WithClauses, Has.Count.EqualTo(1)); + }); + Assert.Multiple(() => + { + Assert.That(query.WithClauses[0].TableName, Is.EqualTo("active_users")); + Assert.That(query.SelectClause.Clause, Is.EqualTo("*")); + Assert.That(query.FromClause.Clause, Is.EqualTo("active_users")); + }); } [Test] @@ -236,11 +269,17 @@ public class QueryBreakdownExtensionsTests .From("active_users u LEFT JOIN recent_orders o ON u.id = o.user_id") .GroupBy("u.id, u.name"); - // Assert - Assert.That(query.IsUsingWithClause, Is.True); - Assert.That(query.WithClauses, Has.Count.EqualTo(2)); - Assert.That(query.WithClauses[0].TableName, Is.EqualTo("active_users")); - Assert.That(query.WithClauses[1].TableName, Is.EqualTo("recent_orders")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.IsUsingWithClause, Is.True); + Assert.That(query.WithClauses, Has.Count.EqualTo(2)); + }); + Assert.Multiple(() => + { + Assert.That(query.WithClauses[0].TableName, Is.EqualTo("active_users")); + Assert.That(query.WithClauses[1].TableName, Is.EqualTo("recent_orders")); + }); } private static readonly string[] columns = new[] { "id", "name", "email" }; @@ -259,10 +298,13 @@ public class QueryBreakdownExtensionsTests var sql = query.GetSql(); - // Assert - Assert.That(query.IsUsingWithClause, Is.True); - Assert.That(query.WithClauses, Has.Count.EqualTo(1)); - Assert.That(sql, Does.Contain("active_users (id, name, email)")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.IsUsingWithClause, Is.True); + Assert.That(query.WithClauses, Has.Count.EqualTo(1)); + Assert.That(sql, Does.Contain("active_users (id, name, email)")); + }); } [Test] @@ -280,9 +322,12 @@ public class QueryBreakdownExtensionsTests .Select("*") .From("active_users"); - // Assert - Assert.That(query.IsUsingWithClause, Is.True); - Assert.That(query.WithClauses, Has.Count.EqualTo(1)); + Assert.Multiple(() => + { + // Assert + Assert.That(query.IsUsingWithClause, Is.True); + Assert.That(query.WithClauses, Has.Count.EqualTo(1)); + }); Assert.That(query.WithClauses[0].TableName, Is.EqualTo("active_users")); } @@ -331,8 +376,11 @@ public class QueryBreakdownExtensionsTests // Assert Assert.That(sql, Does.Contain("WITH")); Assert.That(sql, Does.Contain("monthly_sales AS")); - Assert.That(sql, Does.Contain("LAG(total_sales)")); - Assert.That(query.IsUsingWithClause, Is.True); + Assert.Multiple(() => + { + Assert.That(sql, Does.Contain("LAG(total_sales)")); + Assert.That(query.IsUsingWithClause, Is.True); + }); } [Test] @@ -355,9 +403,12 @@ public class QueryBreakdownExtensionsTests var sql = query.GetSql(); - // Assert - Assert.That(query.WithClauses, Has.Count.EqualTo(2)); - Assert.That(sql, Does.Contain("active_users AS")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.WithClauses, Has.Count.EqualTo(2)); + Assert.That(sql, Does.Contain("active_users AS")); + }); Assert.That(sql, Does.Contain("user_orders AS")); Assert.That(sql, Does.Contain("customer_tier")); } @@ -467,9 +518,12 @@ public class QueryBreakdownExtensionsTests // Act - Overwrite clauses query.Select("id, name").Where("active = 0"); - // Assert - Assert.That(query.SelectClause.Clause, Is.EqualTo("id, name")); - Assert.That(query.WhereClause.Clause, Is.EqualTo("active = 0")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Clause, Is.EqualTo("id, name")); + Assert.That(query.WhereClause.Clause, Is.EqualTo("active = 0")); + }); } [Test] @@ -481,10 +535,13 @@ public class QueryBreakdownExtensionsTests .From("") .Where(""); - // Assert - Assert.That(query.SelectClause.Clause, Is.EqualTo("")); - Assert.That(query.FromClause.Clause, Is.EqualTo("")); - Assert.That(query.WhereClause.Clause, Is.EqualTo("")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Clause, Is.EqualTo("")); + Assert.That(query.FromClause.Clause, Is.EqualTo("")); + Assert.That(query.WhereClause.Clause, Is.EqualTo("")); + }); } [Test] @@ -495,9 +552,12 @@ public class QueryBreakdownExtensionsTests .Select(" id, name ") .From(" users "); - // Assert - Assert.That(query.SelectClause.Clause, Is.EqualTo(" id, name ")); - Assert.That(query.FromClause.Clause, Is.EqualTo(" users ")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Clause, Is.EqualTo(" id, name ")); + Assert.That(query.FromClause.Clause, Is.EqualTo(" users ")); + }); } #endregion diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/JsonTokenReaderTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/JsonTokenReaderTests.cs index 1068e4a..856d3d5 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/JsonTokenReaderTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/JsonTokenReaderTests.cs @@ -33,24 +33,30 @@ public class JsonTokenReaderTests // Validate JSON starts with StartObject and ends with EndObject Assert.That(tokens.Count, Is.GreaterThan(2)); - Assert.That(tokens[0].Type, Is.EqualTo(JsonTokenType.StartObject)); - Assert.That(tokens[^1].Type, Is.EqualTo(JsonTokenType.EndObject)); - Assert.That(tokens.Count(t => t.Type == JsonTokenType.PropertyName && t.Value == "foo"), Is.EqualTo(1)); - Assert.That(tokens.Count(t => t.Type == JsonTokenType.String && t.Value == "bar"), Is.EqualTo(1)); - Assert.That(tokens.Count(t => t.Type == JsonTokenType.PropertyName && t.Value == "myList"), Is.EqualTo(1)); - Assert.That(tokens.Count(t => t.Type == JsonTokenType.StartArray), Is.EqualTo(1)); - Assert.That(tokens.Count(t => t.Type == JsonTokenType.PropertyName && t.Value == "another"), Is.EqualTo(1)); - Assert.That(tokens.Count(t => t.Type == JsonTokenType.Number && t.Value == "12"), Is.EqualTo(1)); + Assert.Multiple(() => + { + Assert.That(tokens[0].Type, Is.EqualTo(JsonTokenType.StartObject)); + Assert.That(tokens[^1].Type, Is.EqualTo(JsonTokenType.EndObject)); + Assert.That(tokens.Count(t => t.Type == JsonTokenType.PropertyName && t.Value == "foo"), Is.EqualTo(1)); + Assert.That(tokens.Count(t => t.Type == JsonTokenType.String && t.Value == "bar"), Is.EqualTo(1)); + Assert.That(tokens.Count(t => t.Type == JsonTokenType.PropertyName && t.Value == "myList"), Is.EqualTo(1)); + Assert.That(tokens.Count(t => t.Type == JsonTokenType.StartArray), Is.EqualTo(1)); + Assert.That(tokens.Count(t => t.Type == JsonTokenType.PropertyName && t.Value == "another"), Is.EqualTo(1)); + Assert.That(tokens.Count(t => t.Type == JsonTokenType.Number && t.Value == "12"), Is.EqualTo(1)); + }); // Deep validation of JSON content structure var tokenIndex = 4; - // Token 4: [ - Assert.That(tokens[tokenIndex++].Type, Is.EqualTo(JsonTokenType.StartArray)); + Assert.Multiple(() => + { + // Token 4: [ + Assert.That(tokens[tokenIndex++].Type, Is.EqualTo(JsonTokenType.StartArray)); - // Token 5-8: Array elements [1,2,3,4] - Assert.That(tokens[tokenIndex].Type, Is.EqualTo(JsonTokenType.Number)); - Assert.That(tokens[tokenIndex++].Value, Is.EqualTo("1")); + // Token 5-8: Array elements [1,2,3,4] + Assert.That(tokens[tokenIndex].Type, Is.EqualTo(JsonTokenType.Number)); + Assert.That(tokens[tokenIndex++].Value, Is.EqualTo("1")); + }); Assert.That(tokens[tokenIndex].Type, Is.EqualTo(JsonTokenType.Number)); Assert.That(tokens[tokenIndex++].Value, Is.EqualTo("2")); Assert.That(tokens[tokenIndex].Type, Is.EqualTo(JsonTokenType.Number)); diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCoreTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCoreTests.cs index 0f5b134..c9765e5 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCoreTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCoreTests.cs @@ -17,9 +17,12 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase // Assert Assert.That(collection, Is.Empty); - Assert.That(collection.IsEmpty, Is.True); - Assert.That(collection.Breakdowns, Is.Empty); - Assert.That(collection.RawStatements, Is.Empty); + Assert.Multiple(() => + { + Assert.That(collection.IsEmpty, Is.True); + Assert.That(collection.Breakdowns, Is.Empty); + Assert.That(collection.RawStatements, Is.Empty); + }); } [Test] @@ -104,9 +107,12 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase // Act var result = collection.Remove(breakdown); - // Assert - Assert.That(result, Is.True); - Assert.That(collection, Is.Empty); + Assert.Multiple(() => + { + // Assert + Assert.That(result, Is.True); + Assert.That(collection, Is.Empty); + }); } [Test] @@ -119,9 +125,12 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase // Act var result = collection.Remove(otherBreakdown); - // Assert - Assert.That(result, Is.False); - Assert.That(collection, Has.Count.EqualTo(1)); + Assert.Multiple(() => + { + // Assert + Assert.That(result, Is.False); + Assert.That(collection, Has.Count.EqualTo(1)); + }); } [Test] @@ -160,9 +169,12 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase // Assert Assert.That(collection.RawStatements, Has.Count.EqualTo(3)); - Assert.That(collection.RawStatements[0], Does.Contain("Table1")); - Assert.That(collection.RawStatements[1], Does.Contain("Table2")); - Assert.That(collection.RawStatements[2], Does.Contain("Table3")); + Assert.Multiple(() => + { + Assert.That(collection.RawStatements[0], Does.Contain("Table1")); + Assert.That(collection.RawStatements[1], Does.Contain("Table2")); + Assert.That(collection.RawStatements[2], Does.Contain("Table3")); + }); } [Test] @@ -223,8 +235,11 @@ public class SqlBreakdownCollectionCoreTests : SqlBreakdownCollectionTestBase // Assert Assert.That(collection.RawStatements, Has.Count.EqualTo(2)); - Assert.That(collection.RawStatements[0], Does.Contain("Table1")); - Assert.That(collection.RawStatements[1], Does.Contain("Table2")); + Assert.Multiple(() => + { + Assert.That(collection.RawStatements[0], Does.Contain("Table1")); + Assert.That(collection.RawStatements[1], Does.Contain("Table2")); + }); } [Test] diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCreateTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCreateTests.cs index 4c904fd..a88ed5e 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCreateTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCreateTests.cs @@ -32,8 +32,11 @@ public class SqlBreakdownCollectionCreateTests : SqlBreakdownCollectionTestBase // Assert Assert.That(collection, Has.Count.EqualTo(2)); - Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE TABLE Users")); - Assert.That(collection.GetRawStatementAt(1), Does.Contain("CREATE TABLE Orders")); + Assert.Multiple(() => + { + Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE TABLE Users")); + Assert.That(collection.GetRawStatementAt(1), Does.Contain("CREATE TABLE Orders")); + }); } [Test] @@ -52,8 +55,11 @@ public class SqlBreakdownCollectionCreateTests : SqlBreakdownCollectionTestBase // Assert Assert.That(collection, Has.Count.EqualTo(2)); - Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE INDEX")); - Assert.That(collection.GetRawStatementAt(1), Does.Contain("UNIQUE")); + Assert.Multiple(() => + { + Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE INDEX")); + Assert.That(collection.GetRawStatementAt(1), Does.Contain("UNIQUE")); + }); } [Test] diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDeleteTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDeleteTests.cs index f33ff55..38370cd 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDeleteTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDeleteTests.cs @@ -26,9 +26,12 @@ public class SqlBreakdownCollectionDeleteTests : SqlBreakdownCollectionTestBase // Assert Assert.That(collection, Has.Count.EqualTo(3)); - Assert.That(collection.GetRawStatementAt(0), Does.Contain("DELETE FROM Orders")); - Assert.That(collection.GetRawStatementAt(1), Does.Contain("NOT IN")); - Assert.That(collection.GetRawStatementAt(2), Does.Contain("DATEADD")); + Assert.Multiple(() => + { + Assert.That(collection.GetRawStatementAt(0), Does.Contain("DELETE FROM Orders")); + Assert.That(collection.GetRawStatementAt(1), Does.Contain("NOT IN")); + Assert.That(collection.GetRawStatementAt(2), Does.Contain("DATEADD")); + }); } [Test] diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDropTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDropTests.cs index 70d81d7..d82fd89 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDropTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDropTests.cs @@ -26,8 +26,11 @@ public class SqlBreakdownCollectionDropTests : SqlBreakdownCollectionTestBase // Assert Assert.That(collection, Has.Count.EqualTo(3)); - Assert.That(collection.GetRawStatementAt(0), Does.Contain("DROP TABLE")); - Assert.That(collection.GetRawStatementAt(1), Does.Contain("DROP TABLE")); + Assert.Multiple(() => + { + Assert.That(collection.GetRawStatementAt(0), Does.Contain("DROP TABLE")); + Assert.That(collection.GetRawStatementAt(1), Does.Contain("DROP TABLE")); + }); } [Test] @@ -48,8 +51,11 @@ public class SqlBreakdownCollectionDropTests : SqlBreakdownCollectionTestBase // Assert Assert.That(collection, Has.Count.EqualTo(3)); - Assert.That(collection.GetRawStatementAt(0), Does.Contain("DROP INDEX")); - Assert.That(collection.GetRawStatementAt(1), Does.Contain("PROCEDURE")); - Assert.That(collection.GetRawStatementAt(2), Does.Contain("VIEW")); + Assert.Multiple(() => + { + Assert.That(collection.GetRawStatementAt(0), Does.Contain("DROP INDEX")); + Assert.That(collection.GetRawStatementAt(1), Does.Contain("PROCEDURE")); + Assert.That(collection.GetRawStatementAt(2), Does.Contain("VIEW")); + }); } } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionInsertTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionInsertTests.cs index 8dde3fd..21acaed 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionInsertTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionInsertTests.cs @@ -26,9 +26,12 @@ public class SqlBreakdownCollectionInsertTests : SqlBreakdownCollectionTestBase // Assert Assert.That(collection, Has.Count.EqualTo(3)); - Assert.That(collection.GetRawStatementAt(0), Does.Contain("INSERT INTO Users")); - Assert.That(collection.GetRawStatementAt(1), Does.Contain("Jane Smith")); - Assert.That(collection.GetRawStatementAt(2), Does.Contain("Bob Johnson")); + Assert.Multiple(() => + { + Assert.That(collection.GetRawStatementAt(0), Does.Contain("INSERT INTO Users")); + Assert.That(collection.GetRawStatementAt(1), Does.Contain("Jane Smith")); + Assert.That(collection.GetRawStatementAt(2), Does.Contain("Bob Johnson")); + }); } [Test] diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionMixedCrudTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionMixedCrudTests.cs index c1577bc..906e7af 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionMixedCrudTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionMixedCrudTests.cs @@ -38,12 +38,15 @@ public class SqlBreakdownCollectionMixedCrudTests : SqlBreakdownCollectionTestBa // Assert Assert.That(collection, Has.Count.EqualTo(7)); - Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE TABLE")); - Assert.That(collection.GetRawStatementAt(1), Does.Contain("INSERT")); - Assert.That(collection.GetRawStatementAt(3), Does.Contain("SELECT")); - Assert.That(collection.GetRawStatementAt(4), Does.Contain("UPDATE")); - Assert.That(collection.GetRawStatementAt(5), Does.Contain("DELETE")); - Assert.That(collection.GetRawStatementAt(6), Does.Contain("DROP")); + Assert.Multiple(() => + { + Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE TABLE")); + Assert.That(collection.GetRawStatementAt(1), Does.Contain("INSERT")); + Assert.That(collection.GetRawStatementAt(3), Does.Contain("SELECT")); + Assert.That(collection.GetRawStatementAt(4), Does.Contain("UPDATE")); + Assert.That(collection.GetRawStatementAt(5), Does.Contain("DELETE")); + Assert.That(collection.GetRawStatementAt(6), Does.Contain("DROP")); + }); } [Test] diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionParameterTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionParameterTests.cs index 7992366..13d4e2c 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionParameterTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionParameterTests.cs @@ -44,8 +44,11 @@ public class SqlBreakdownCollectionParameterTests : SqlBreakdownCollectionTestBa // Assert Assert.That(collection, Has.Count.EqualTo(2)); - Assert.That(collection.GetRawStatementAt(0), Does.Contain("@Name")); - Assert.That(collection.GetRawStatementAt(1), Does.Contain("@Status")); + Assert.Multiple(() => + { + Assert.That(collection.GetRawStatementAt(0), Does.Contain("@Name")); + Assert.That(collection.GetRawStatementAt(1), Does.Contain("@Status")); + }); } [Test] diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSelectTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSelectTests.cs index e198fa7..6dab82b 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSelectTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSelectTests.cs @@ -31,8 +31,11 @@ public class SqlBreakdownCollectionSelectTests : SqlBreakdownCollectionTestBase // Assert Assert.That(collection, Has.Count.EqualTo(2)); Assert.That(collection.GetRawStatementAt(0), Does.Contain("LEFT JOIN")); - Assert.That(collection.GetRawStatementAt(0), Does.Contain("GROUP BY")); - Assert.That(collection.GetRawStatementAt(1), Does.Contain("BETWEEN")); + Assert.Multiple(() => + { + Assert.That(collection.GetRawStatementAt(0), Does.Contain("GROUP BY")); + Assert.That(collection.GetRawStatementAt(1), Does.Contain("BETWEEN")); + }); } [Test] @@ -80,7 +83,10 @@ public class SqlBreakdownCollectionSelectTests : SqlBreakdownCollectionTestBase // Assert Assert.That(collection, Has.Count.EqualTo(2)); - Assert.That(collection.GetRawStatementAt(0), Does.Contain("JOIN")); - Assert.That(collection.GetRawStatementAt(1), Does.Contain("IN")); + Assert.Multiple(() => + { + Assert.That(collection.GetRawStatementAt(0), Does.Contain("JOIN")); + Assert.That(collection.GetRawStatementAt(1), Does.Contain("IN")); + }); } } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSeparatorTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSeparatorTests.cs index 80bfb80..d859e29 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSeparatorTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSeparatorTests.cs @@ -26,9 +26,12 @@ public class SqlBreakdownCollectionSeparatorTests : SqlBreakdownCollectionTestBa // Assert Assert.That(collection, Has.Count.EqualTo(3)); - Assert.That(collection.GetRawStatementAt(0), Does.Contain("Users")); - Assert.That(collection.GetRawStatementAt(1), Does.Contain("Orders")); - Assert.That(collection.GetRawStatementAt(2), Does.Contain("Products")); + Assert.Multiple(() => + { + Assert.That(collection.GetRawStatementAt(0), Does.Contain("Users")); + Assert.That(collection.GetRawStatementAt(1), Does.Contain("Orders")); + Assert.That(collection.GetRawStatementAt(2), Does.Contain("Products")); + }); } [Test] diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionUpdateTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionUpdateTests.cs index ba32431..430d8b8 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionUpdateTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionUpdateTests.cs @@ -26,9 +26,12 @@ public class SqlBreakdownCollectionUpdateTests : SqlBreakdownCollectionTestBase // Assert Assert.That(collection, Has.Count.EqualTo(3)); - Assert.That(collection.GetRawStatementAt(0), Does.Contain("UPDATE Users")); - Assert.That(collection.GetRawStatementAt(1), Does.Contain("Status")); - Assert.That(collection.GetRawStatementAt(2), Does.Contain("Price * 1.1")); + Assert.Multiple(() => + { + Assert.That(collection.GetRawStatementAt(0), Does.Contain("UPDATE Users")); + Assert.That(collection.GetRawStatementAt(1), Does.Contain("Status")); + Assert.That(collection.GetRawStatementAt(2), Does.Contain("Price * 1.1")); + }); } [Test] @@ -53,8 +56,11 @@ public class SqlBreakdownCollectionUpdateTests : SqlBreakdownCollectionTestBase // Assert Assert.That(collection, Has.Count.EqualTo(2)); - Assert.That(collection.GetRawStatementAt(0), Does.Contain("UPDATE u")); - Assert.That(collection.GetRawStatementAt(1), Does.Contain("Quantity - 1")); + Assert.Multiple(() => + { + Assert.That(collection.GetRawStatementAt(0), Does.Contain("UPDATE u")); + Assert.That(collection.GetRawStatementAt(1), Does.Contain("Quantity - 1")); + }); } [Test] diff --git a/tests/Strata.SqlTools.SqlServer.Tests/Performance/GetClausesCachingTests.cs b/tests/Strata.SqlTools.SqlServer.Tests/Performance/GetClausesCachingTests.cs index 1eb62d3..20bc705 100644 --- a/tests/Strata.SqlTools.SqlServer.Tests/Performance/GetClausesCachingTests.cs +++ b/tests/Strata.SqlTools.SqlServer.Tests/Performance/GetClausesCachingTests.cs @@ -181,8 +181,11 @@ public class GetClausesCachingTests // Assert Assert.That(clauses2, Is.Not.SameAs(clauses1), "GetClauses should return a new instance after ApplyClauses"); - Assert.That(clauses2.SelectClause?.Clause, Is.EqualTo("id, name")); - Assert.That(clauses2.FromClause?.Clause, Is.EqualTo("customers")); + Assert.Multiple(() => + { + Assert.That(clauses2.SelectClause?.Clause, Is.EqualTo("id, name")); + Assert.That(clauses2.FromClause?.Clause, Is.EqualTo("customers")); + }); } [Test] @@ -197,10 +200,13 @@ public class GetClausesCachingTests // Assert Assert.That(clauses, Is.Not.Null); - Assert.That(clauses.SelectClause?.Clause, Is.EqualTo("id, name")); - Assert.That(clauses.FromClause?.Clause, Is.EqualTo("users")); - Assert.That(clauses.WhereClause?.Clause, Is.EqualTo("active = 1")); - Assert.That(clauses.OrderByClause?.Clause, Is.EqualTo("name ASC")); + Assert.Multiple(() => + { + Assert.That(clauses.SelectClause?.Clause, Is.EqualTo("id, name")); + Assert.That(clauses.FromClause?.Clause, Is.EqualTo("users")); + Assert.That(clauses.WhereClause?.Clause, Is.EqualTo("active = 1")); + Assert.That(clauses.OrderByClause?.Clause, Is.EqualTo("name ASC")); + }); } [Test] @@ -214,8 +220,11 @@ public class GetClausesCachingTests var clauses2 = query.GetClauses(); var clauses3 = query.GetClauses(); - // Assert - All should be the same instance - Assert.That(clauses2, Is.SameAs(clauses1)); - Assert.That(clauses3, Is.SameAs(clauses1)); + Assert.Multiple(() => + { + // Assert - All should be the same instance + Assert.That(clauses2, Is.SameAs(clauses1)); + Assert.That(clauses3, Is.SameAs(clauses1)); + }); } } diff --git a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/CTEColumnListTests.cs b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/CTEColumnListTests.cs index c06f4ba..3adfdb2 100644 --- a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/CTEColumnListTests.cs +++ b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/CTEColumnListTests.cs @@ -20,9 +20,12 @@ public class CTEColumnListTests // Act & Assert Assert.That(withClause.ColumnList, Has.Count.EqualTo(3)); - Assert.That(withClause.ColumnList[0], Is.EqualTo("user_id")); - Assert.That(withClause.ColumnList[1], Is.EqualTo("user_name")); - Assert.That(withClause.ColumnList[2], Is.EqualTo("user_email")); + Assert.Multiple(() => + { + Assert.That(withClause.ColumnList[0], Is.EqualTo("user_id")); + Assert.That(withClause.ColumnList[1], Is.EqualTo("user_name")); + Assert.That(withClause.ColumnList[2], Is.EqualTo("user_email")); + }); } [Test] @@ -362,9 +365,12 @@ public class CTEColumnListTests // Assert Assert.That(sql, Contains.Substring("recent_sales (cust_id, order_id, sale_date, amount)")); var paramKeys = params_all.Keys.ToList(); - Assert.That(paramKeys.Any(k => k.Contains("StartDate"))); - Assert.That(paramKeys.Any(k => k.Contains("MinAmount"))); - Assert.That(paramKeys.Any(k => k.Contains("CurrencyConversion"))); + Assert.Multiple(() => + { + Assert.That(paramKeys.Any(k => k.Contains("StartDate"))); + Assert.That(paramKeys.Any(k => k.Contains("MinAmount"))); + Assert.That(paramKeys.Any(k => k.Contains("CurrencyConversion"))); + }); } #endregion diff --git a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/CommentTests.cs b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/CommentTests.cs index b39cd29..45e06de 100644 --- a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/CommentTests.cs +++ b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/CommentTests.cs @@ -21,8 +21,11 @@ public class CommentTests // Assert Assert.That(query.SelectClause.Clause, Does.Contain("ID")); Assert.That(query.SelectClause.Clause, Does.Contain("Name")); - Assert.That(query.SelectClause.Clause, Does.Contain("Email")); - Assert.That(query.SelectClause.Comment, Does.Contain("-- This is a customer name")); + Assert.Multiple(() => + { + Assert.That(query.SelectClause.Clause, Does.Contain("Email")); + Assert.That(query.SelectClause.Comment, Does.Contain("-- This is a customer name")); + }); } [Test] @@ -42,8 +45,11 @@ public class CommentTests // Assert Assert.That(query.SelectClause.Clause, Does.Contain("ID")); - Assert.That(query.SelectClause.Clause, Does.Contain("Name")); - Assert.That(query.SelectClause.Comment, Does.Contain("/* Multi-line comment")); + Assert.Multiple(() => + { + Assert.That(query.SelectClause.Clause, Does.Contain("Name")); + Assert.That(query.SelectClause.Comment, Does.Contain("/* Multi-line comment")); + }); Assert.That(query.SelectClause.Comment, Does.Contain("explaining the query */")); } @@ -64,11 +70,14 @@ public class CommentTests // Act var query = QueryBreakdown.Parse(sql); - // Assert - Assert.That(query.SelectClause.Comment, Does.Contain("-- Select specific columns")); - Assert.That(query.FromClause.Comment, Does.Contain("-- Main user table")); - Assert.That(query.WhereClause.Comment, Does.Contain("/* Active users only */")); - Assert.That(query.OrderByClause.Comment, Does.Contain("-- Sort by name")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Comment, Does.Contain("-- Select specific columns")); + Assert.That(query.FromClause.Comment, Does.Contain("-- Main user table")); + Assert.That(query.WhereClause.Comment, Does.Contain("/* Active users only */")); + Assert.That(query.OrderByClause.Comment, Does.Contain("-- Sort by name")); + }); } [Test] @@ -100,10 +109,13 @@ public class CommentTests // Act var query = QueryBreakdown.Parse(sql); - // Assert - Assert.That(query.SelectClause.Comment, Is.Null.Or.Empty); - Assert.That(query.FromClause.Comment, Is.Null.Or.Empty); - Assert.That(query.WhereClause.Comment, Is.Null.Or.Empty); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Comment, Is.Null.Or.Empty); + Assert.That(query.FromClause.Comment, Is.Null.Or.Empty); + Assert.That(query.WhereClause.Comment, Is.Null.Or.Empty); + }); } [Test] @@ -121,10 +133,13 @@ public class CommentTests // Act var cloned = (QueryBreakdown)original.Clone(); - // Assert - Assert.That(cloned.SelectClause.Comment, Is.EqualTo(original.SelectClause.Comment)); - Assert.That(cloned.FromClause.Comment, Is.EqualTo(original.FromClause.Comment)); - Assert.That(cloned.WhereClause.Comment, Is.EqualTo(original.WhereClause.Comment)); + Assert.Multiple(() => + { + // Assert + Assert.That(cloned.SelectClause.Comment, Is.EqualTo(original.SelectClause.Comment)); + Assert.That(cloned.FromClause.Comment, Is.EqualTo(original.FromClause.Comment)); + Assert.That(cloned.WhereClause.Comment, Is.EqualTo(original.WhereClause.Comment)); + }); } [Test] @@ -221,10 +236,16 @@ public class CommentTests // Assert Assert.That(comments, Has.Count.EqualTo(2)); - Assert.That(comments[0], Does.Contain("-- Single line")); - Assert.That(comments[1], Does.Contain("/* Multi")); - Assert.That(comments[1], Does.Contain("line */")); - Assert.That(cleanSql, Does.Not.Contain("-- Single line")); + Assert.Multiple(() => + { + Assert.That(comments[0], Does.Contain("-- Single line")); + Assert.That(comments[1], Does.Contain("/* Multi")); + }); + Assert.Multiple(() => + { + Assert.That(comments[1], Does.Contain("line */")); + Assert.That(cleanSql, Does.Not.Contain("-- Single line")); + }); Assert.That(cleanSql, Does.Not.Contain("/*")); } @@ -257,15 +278,21 @@ public class CommentTests Assert.That(query.SelectClause.Clause, Does.Contain("Name")); Assert.That(query.SelectClause.Clause, Does.Contain("Email")); Assert.That(query.SelectClause.Clause, Does.Not.Contain("--")); - Assert.That(query.SelectClause.Clause, Does.Not.Contain("/*")); + Assert.Multiple(() => + { + Assert.That(query.SelectClause.Clause, Does.Not.Contain("/*")); - Assert.That(query.SelectClause.Comment, Does.Contain("-- Primary key")); + Assert.That(query.SelectClause.Comment, Does.Contain("-- Primary key")); + }); Assert.That(query.SelectClause.Comment, Does.Contain("-- Customer name field")); - Assert.That(query.SelectClause.Comment, Does.Contain("/* Email address for notifications */")); + Assert.Multiple(() => + { + Assert.That(query.SelectClause.Comment, Does.Contain("/* Email address for notifications */")); - Assert.That(query.FromClause.Comment, Does.Contain("-- Main user table")); - Assert.That(query.WhereClause.Comment, Does.Contain("/* Filter for active users only */")); - Assert.That(query.OrderByClause.Comment, Does.Contain("-- Sort alphabetically")); + Assert.That(query.FromClause.Comment, Does.Contain("-- Main user table")); + Assert.That(query.WhereClause.Comment, Does.Contain("/* Filter for active users only */")); + Assert.That(query.OrderByClause.Comment, Does.Contain("-- Sort alphabetically")); + }); // Act - Generate SQL var regeneratedSql = query.GetSql(); diff --git a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownCollectionTests.cs b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownCollectionTests.cs index 420ef97..660c016 100644 --- a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownCollectionTests.cs +++ b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownCollectionTests.cs @@ -87,9 +87,12 @@ public class QueryBreakdownCollectionTests // Act var removed = _collection.Remove(query); - // Assert - Assert.That(removed, Is.True); - Assert.That(_collection, Is.Empty); + Assert.Multiple(() => + { + // Assert + Assert.That(removed, Is.True); + Assert.That(_collection, Is.Empty); + }); } [Test] @@ -103,9 +106,12 @@ public class QueryBreakdownCollectionTests // Act var removed = _collection.Remove(query2); - // Assert - Assert.That(removed, Is.False); - Assert.That(_collection, Has.Count.EqualTo(1)); + Assert.Multiple(() => + { + // Assert + Assert.That(removed, Is.False); + Assert.That(_collection, Has.Count.EqualTo(1)); + }); } [Test] @@ -276,8 +282,11 @@ public class QueryBreakdownCollectionTests // Assert Assert.That(summaries, Has.Count.EqualTo(2)); - Assert.That(summaries[0].HasSelectClause, Is.True); - Assert.That(summaries[1].HasWhereClause, Is.True); + Assert.Multiple(() => + { + Assert.That(summaries[0].HasSelectClause, Is.True); + Assert.That(summaries[1].HasWhereClause, Is.True); + }); } [Test] @@ -327,9 +336,12 @@ public class QueryBreakdownCollectionTests // Act _collection.AddParameterToAll("CompanyId", 99); - // Assert - Assert.That(_collection.QueryBreakdowns[0].Parameters["CompanyId"], Is.EqualTo(99)); - Assert.That(_collection.QueryBreakdowns[1].Parameters["CompanyId"], Is.EqualTo(99)); + Assert.Multiple(() => + { + // Assert + Assert.That(_collection.QueryBreakdowns[0].Parameters["CompanyId"], Is.EqualTo(99)); + Assert.That(_collection.QueryBreakdowns[1].Parameters["CompanyId"], Is.EqualTo(99)); + }); } [Test] diff --git a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownTests.cs b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownTests.cs index 423699e..0ec2a87 100644 --- a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownTests.cs +++ b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownTests.cs @@ -16,16 +16,19 @@ public class QueryBreakdownTests // Arrange & Act var query = new QueryBreakdown(); - // Assert - Assert.That(query.SelectClause.Clause, Is.EqualTo(string.Empty)); - Assert.That(query.FromClause.Clause, Is.EqualTo(string.Empty)); - Assert.That(query.WhereClause.Clause, Is.EqualTo(string.Empty)); - Assert.That(query.OrderByClause.Clause, Is.EqualTo(string.Empty)); - Assert.That(query.GroupByClause.Clause, Is.EqualTo(string.Empty)); - Assert.That(query.HavingClause.Clause, Is.EqualTo(string.Empty)); - Assert.That(query.SetupClauses, Is.Not.Null); - Assert.That(query.FinishClauses, Is.Not.Null); - Assert.That(query.WithClauses, Is.Not.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Clause, Is.EqualTo(string.Empty)); + Assert.That(query.FromClause.Clause, Is.EqualTo(string.Empty)); + Assert.That(query.WhereClause.Clause, Is.EqualTo(string.Empty)); + Assert.That(query.OrderByClause.Clause, Is.EqualTo(string.Empty)); + Assert.That(query.GroupByClause.Clause, Is.EqualTo(string.Empty)); + Assert.That(query.HavingClause.Clause, Is.EqualTo(string.Empty)); + Assert.That(query.SetupClauses, Is.Not.Null); + Assert.That(query.FinishClauses, Is.Not.Null); + Assert.That(query.WithClauses, Is.Not.Null); + }); Assert.That(query.WithClauses, Is.Empty); Assert.That(query.Parameters, Is.Not.Null); Assert.That(query.ParameterList, Is.Not.Null); @@ -41,10 +44,13 @@ public class QueryBreakdownTests // Act var query = new QueryBreakdown(selectClause, fromClause); - // Assert - Assert.That(query.SelectClause.Clause, Is.EqualTo(selectClause)); - Assert.That(query.FromClause.Clause, Is.EqualTo(fromClause)); - Assert.That(query.WhereClause.Clause, Is.EqualTo(string.Empty)); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Clause, Is.EqualTo(selectClause)); + Assert.That(query.FromClause.Clause, Is.EqualTo(fromClause)); + Assert.That(query.WhereClause.Clause, Is.EqualTo(string.Empty)); + }); } [Test] @@ -58,11 +64,14 @@ public class QueryBreakdownTests // Act var query = new QueryBreakdown(selectClause, fromClause, whereClause); - // Assert - Assert.That(query.SelectClause.Clause, Is.EqualTo(selectClause)); - Assert.That(query.FromClause.Clause, Is.EqualTo(fromClause)); - Assert.That(query.WhereClause.Clause, Is.EqualTo(whereClause)); - Assert.That(query.OrderByClause.Clause, Is.EqualTo(string.Empty)); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Clause, Is.EqualTo(selectClause)); + Assert.That(query.FromClause.Clause, Is.EqualTo(fromClause)); + Assert.That(query.WhereClause.Clause, Is.EqualTo(whereClause)); + Assert.That(query.OrderByClause.Clause, Is.EqualTo(string.Empty)); + }); } [Test] @@ -77,11 +86,14 @@ public class QueryBreakdownTests // Act var query = new QueryBreakdown(selectClause, fromClause, whereClause, orderByClause); - // Assert - Assert.That(query.SelectClause.Clause, Is.EqualTo(selectClause)); - Assert.That(query.FromClause.Clause, Is.EqualTo(fromClause)); - Assert.That(query.WhereClause.Clause, Is.EqualTo(whereClause)); - Assert.That(query.OrderByClause.Clause, Is.EqualTo(orderByClause)); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Clause, Is.EqualTo(selectClause)); + Assert.That(query.FromClause.Clause, Is.EqualTo(fromClause)); + Assert.That(query.WhereClause.Clause, Is.EqualTo(whereClause)); + Assert.That(query.OrderByClause.Clause, Is.EqualTo(orderByClause)); + }); } #endregion @@ -147,9 +159,12 @@ public class QueryBreakdownTests // Act query.AddParameter("UserId", 123); - // Assert - Assert.That(query.ParameterList.Count(), Is.EqualTo(1)); - Assert.That(query.Parameters["@UserId"], Is.EqualTo(123)); + Assert.Multiple(() => + { + // Assert + Assert.That(query.ParameterList.Count(), Is.EqualTo(1)); + Assert.That(query.Parameters["@UserId"], Is.EqualTo(123)); + }); } [Test] @@ -209,8 +224,11 @@ public class QueryBreakdownTests // Assert Assert.That(merged, Has.Count.EqualTo(2)); - Assert.That(merged["@UserId"], Is.EqualTo(123)); - Assert.That(merged["@ActiveStatus"], Is.EqualTo(true)); + Assert.Multiple(() => + { + Assert.That(merged["@UserId"], Is.EqualTo(123)); + Assert.That(merged["@ActiveStatus"], Is.EqualTo(true)); + }); } [Test] @@ -229,8 +247,11 @@ public class QueryBreakdownTests // Assert Assert.That(merged, Has.Count.EqualTo(2)); - Assert.That(merged["@MinDate"], Is.EqualTo(DateTime.Today.AddDays(-30))); - Assert.That(merged["@Limit"], Is.EqualTo(100)); + Assert.Multiple(() => + { + Assert.That(merged["@MinDate"], Is.EqualTo(DateTime.Today.AddDays(-30))); + Assert.That(merged["@Limit"], Is.EqualTo(100)); + }); } [Test] @@ -253,9 +274,12 @@ public class QueryBreakdownTests // Assert Assert.That(merged, Has.Count.EqualTo(3)); - Assert.That(merged["@Status1"], Is.EqualTo("active")); - Assert.That(merged["@MinDate"], Is.EqualTo(DateTime.Today.AddDays(-30))); - Assert.That(merged["@ResultLimit"], Is.EqualTo(50)); + Assert.Multiple(() => + { + Assert.That(merged["@Status1"], Is.EqualTo("active")); + Assert.That(merged["@MinDate"], Is.EqualTo(DateTime.Today.AddDays(-30))); + Assert.That(merged["@ResultLimit"], Is.EqualTo(50)); + }); } [Test] @@ -297,9 +321,12 @@ public class QueryBreakdownTests // Assert - All parameters from all levels should be present Assert.That(merged, Has.Count.EqualTo(3)); - Assert.That(merged["@InnerParam"], Is.EqualTo("inner_value")); - Assert.That(merged["@MiddleParam"], Is.EqualTo("middle_value")); - Assert.That(merged["@MainParam"], Is.EqualTo("main_value")); + Assert.Multiple(() => + { + Assert.That(merged["@InnerParam"], Is.EqualTo("inner_value")); + Assert.That(merged["@MiddleParam"], Is.EqualTo("middle_value")); + Assert.That(merged["@MainParam"], Is.EqualTo("main_value")); + }); } [Test] @@ -336,11 +363,14 @@ public class QueryBreakdownTests // Act var merged = mainQuery.GetMergedParameters(); - // Assert - Assert.That(merged["@IntValue"], Is.TypeOf()); - Assert.That(merged["@StringValue"], Is.TypeOf()); - Assert.That(merged["@DateValue"], Is.TypeOf()); - Assert.That(merged["@DecimalValue"], Is.TypeOf()); + Assert.Multiple(() => + { + // Assert + Assert.That(merged["@IntValue"], Is.TypeOf()); + Assert.That(merged["@StringValue"], Is.TypeOf()); + Assert.That(merged["@DateValue"], Is.TypeOf()); + Assert.That(merged["@DecimalValue"], Is.TypeOf()); + }); } #endregion @@ -413,12 +443,18 @@ public class QueryBreakdownTests // Act query.AddWhereClause("UserID = @UserId AND Status = @Status"); - // Assert - Assert.That(query.WhereClause.Clause, Is.EqualTo("UserID = @UserId AND Status = @Status")); - Assert.That(query.Parameters, Does.ContainKey("@UserId")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.WhereClause.Clause, Is.EqualTo("UserID = @UserId AND Status = @Status")); + Assert.That(query.Parameters, Does.ContainKey("@UserId")); + }); Assert.That(query.Parameters, Does.ContainKey("@Status")); - Assert.That(query.Parameters["@UserId"], Is.Null); - Assert.That(query.Parameters["@Status"], Is.Null); + Assert.Multiple(() => + { + Assert.That(query.Parameters["@UserId"], Is.Null); + Assert.That(query.Parameters["@Status"], Is.Null); + }); } [Test] @@ -481,9 +517,12 @@ public class QueryBreakdownTests // Act - AddWhereClause should not overwrite existing non-null values query.AddWhereClause("UserID = @UserId AND Status = @Status"); - // Assert - Values should be preserved - Assert.That(query.Parameters["@UserId"], Is.EqualTo(123)); - Assert.That(query.Parameters["@Status"], Is.EqualTo("Active")); + Assert.Multiple(() => + { + // Assert - Values should be preserved + Assert.That(query.Parameters["@UserId"], Is.EqualTo(123)); + Assert.That(query.Parameters["@Status"], Is.EqualTo("Active")); + }); } #endregion @@ -567,8 +606,11 @@ public class QueryBreakdownTests // Assert Assert.That(mainQuery.WithClauses, Has.Count.EqualTo(1)); - Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("ProductOrders")); - Assert.That(mainQuery.WithClauses[0].Query, Is.EqualTo(cteQuery)); + Assert.Multiple(() => + { + Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("ProductOrders")); + Assert.That(mainQuery.WithClauses[0].Query, Is.EqualTo(cteQuery)); + }); } [Test] @@ -587,9 +629,12 @@ public class QueryBreakdownTests // Assert Assert.That(mainQuery.WithClauses, Has.Count.EqualTo(3)); - Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("CTE1")); - Assert.That(mainQuery.WithClauses[1].TableName, Is.EqualTo("CTE2")); - Assert.That(mainQuery.WithClauses[2].TableName, Is.EqualTo("CTE3")); + Assert.Multiple(() => + { + Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("CTE1")); + Assert.That(mainQuery.WithClauses[1].TableName, Is.EqualTo("CTE2")); + Assert.That(mainQuery.WithClauses[2].TableName, Is.EqualTo("CTE3")); + }); } [Test] @@ -604,9 +649,12 @@ public class QueryBreakdownTests // Assert Assert.That(mainQuery.WithClauses, Has.Count.EqualTo(1)); - Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("ProductOrders")); - Assert.That(mainQuery.WithClauses[0].Query!.SelectClause.Clause, Does.Contain("ProductID")); - Assert.That(mainQuery.WithClauses[0].Query!.GroupByClause.Clause, Does.Contain("ProductID")); + Assert.Multiple(() => + { + Assert.That(mainQuery.WithClauses[0].TableName, Is.EqualTo("ProductOrders")); + Assert.That(mainQuery.WithClauses[0].Query!.SelectClause.Clause, Does.Contain("ProductID")); + Assert.That(mainQuery.WithClauses[0].Query!.GroupByClause.Clause, Does.Contain("ProductID")); + }); } [Test] @@ -665,11 +713,14 @@ public class QueryBreakdownTests var innerParams = innerCte.ParameterList.Count(); var middleParams = middleCte.ParameterList.Count(); - // Assert - Each CTE maintains its own parameters - Assert.That(innerParams, Is.EqualTo(1)); - Assert.That(middleParams, Is.EqualTo(1)); - // SQL should contain both WITH clauses - Assert.That(sql, Does.Contain("WITH")); + Assert.Multiple(() => + { + // Assert - Each CTE maintains its own parameters + Assert.That(innerParams, Is.EqualTo(1)); + Assert.That(middleParams, Is.EqualTo(1)); + // SQL should contain both WITH clauses + Assert.That(sql, Does.Contain("WITH")); + }); Assert.That(sql, Does.Contain("recent_users")); Assert.That(sql, Does.Contain("filtered_users")); } @@ -722,8 +773,11 @@ public class QueryBreakdownTests // Assert - Verify WITH clause appears before main SELECT var withIndex = sql.IndexOf("WITH"); var mainSelectIndex = sql.LastIndexOf("SELECT"); - Assert.That(withIndex, Is.GreaterThan(-1)); - Assert.That(mainSelectIndex, Is.GreaterThan(-1)); + Assert.Multiple(() => + { + Assert.That(withIndex, Is.GreaterThan(-1)); + Assert.That(mainSelectIndex, Is.GreaterThan(-1)); + }); Assert.That(withIndex, Is.LessThan(mainSelectIndex)); // Assert - Verify CTE definition @@ -745,13 +799,19 @@ public class QueryBreakdownTests var sql = mainQuery.GetSql(); var withClause = mainQuery.WithClauses[0]; - // Assert: Verify WithClause properties - Assert.That(withClause.TableName, Is.EqualTo("sales_team")); - Assert.That(withClause.Query, Is.Not.Null); - Assert.That(withClause.Sql, Is.Not.Null); - Assert.That(withClause.Sql?.SelectClause?.Clause, Contains.Substring("id, name")); - Assert.That(withClause.Sql?.FromClause?.Clause, Contains.Substring("employees")); - Assert.That(withClause.Sql?.WhereClause?.Clause, Contains.Substring("department = 'Sales'")); + Assert.Multiple(() => + { + // Assert: Verify WithClause properties + Assert.That(withClause.TableName, Is.EqualTo("sales_team")); + Assert.That(withClause.Query, Is.Not.Null); + Assert.That(withClause.Sql, Is.Not.Null); + }); + Assert.Multiple(() => + { + Assert.That(withClause.Sql?.SelectClause?.Clause, Contains.Substring("id, name")); + Assert.That(withClause.Sql?.FromClause?.Clause, Contains.Substring("employees")); + Assert.That(withClause.Sql?.WhereClause?.Clause, Contains.Substring("department = 'Sales'")); + }); } [Test] @@ -767,9 +827,12 @@ public class QueryBreakdownTests var cte = new QueryBreakdown("id, name", "source_table"); query.AddWithClause("source_cte", cte); - // Assert - Now using WITH clause - Assert.That(query.IsUsingWithClause, Is.True); - Assert.That(query.WithClauses, Has.Count.EqualTo(1)); + Assert.Multiple(() => + { + // Assert - Now using WITH clause + Assert.That(query.IsUsingWithClause, Is.True); + Assert.That(query.WithClauses, Has.Count.EqualTo(1)); + }); } #endregion @@ -925,9 +988,12 @@ public class QueryBreakdownTests // Act var query = QueryBreakdown.Parse(sql); - // Assert - Assert.That(query.SelectClause.Clause?.Trim(), Does.Contain("ID, Name")); - Assert.That(query.FromClause.Clause?.Trim(), Does.Contain("Users")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Clause?.Trim(), Does.Contain("ID, Name")); + Assert.That(query.FromClause.Clause?.Trim(), Does.Contain("Users")); + }); } [Test] @@ -939,10 +1005,13 @@ public class QueryBreakdownTests // Act var query = QueryBreakdown.Parse(sql); - // Assert - Assert.That(query.SelectClause.Clause?.Trim(), Does.Contain("ID, Name")); - Assert.That(query.FromClause.Clause?.Trim(), Does.Contain("Users")); - Assert.That(query.WhereClause.Clause?.Trim(), Does.Contain("Active = 1")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Clause?.Trim(), Does.Contain("ID, Name")); + Assert.That(query.FromClause.Clause?.Trim(), Does.Contain("Users")); + Assert.That(query.WhereClause.Clause?.Trim(), Does.Contain("Active = 1")); + }); } [Test] @@ -954,10 +1023,13 @@ public class QueryBreakdownTests // Act var query = QueryBreakdown.Parse(sql); - // Assert - Assert.That(query.SelectClause.Clause?.Trim(), Does.Contain("Department")); - Assert.That(query.GroupByClause.Clause?.Trim(), Does.Contain("Department")); - Assert.That(query.HavingClause.Clause?.Trim(), Does.Contain("COUNT(*) > 5")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Clause?.Trim(), Does.Contain("Department")); + Assert.That(query.GroupByClause.Clause?.Trim(), Does.Contain("Department")); + Assert.That(query.HavingClause.Clause?.Trim(), Does.Contain("COUNT(*) > 5")); + }); } [Test] @@ -1003,10 +1075,13 @@ public class QueryBreakdownTests // Act var query = QueryBreakdown.Parse(sql); - // Assert - Assert.That(query.IsUsingWithClause, Is.True); - Assert.That(query.SelectClause.Clause?.Trim(), Does.Contain("p.*, ps.TotalQty")); - Assert.That(query.FromClause.Clause?.Trim(), Does.Contain("Products p")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.IsUsingWithClause, Is.True); + Assert.That(query.SelectClause.Clause?.Trim(), Does.Contain("p.*, ps.TotalQty")); + Assert.That(query.FromClause.Clause?.Trim(), Does.Contain("Products p")); + }); } [Test] @@ -1042,9 +1117,12 @@ public class QueryBreakdownTests // Act var success = QueryBreakdown.TryParse(sql, out var query); - // Assert - Assert.That(success, Is.True); - Assert.That(query, Is.Not.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.True); + Assert.That(query, Is.Not.Null); + }); } [Test] @@ -1056,10 +1134,13 @@ public class QueryBreakdownTests // Act var success = QueryBreakdown.TryParse(sql, out var query, out var error); - // Assert - Assert.That(success, Is.False); - Assert.That(query, Is.Null); - Assert.That(error, Is.Not.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.False); + Assert.That(query, Is.Null); + Assert.That(error, Is.Not.Null); + }); } #endregion @@ -1134,10 +1215,13 @@ public class QueryBreakdownTests // Assert Assert.That(clone, Is.Not.SameAs(original)); - Assert.That(clone.SelectClause.Clause, Is.EqualTo(original.SelectClause.Clause)); - Assert.That(clone.FromClause.Clause, Is.EqualTo(original.FromClause.Clause)); - Assert.That(clone.WhereClause.Clause, Is.EqualTo(original.WhereClause.Clause)); - Assert.That(clone.OrderByClause.Clause, Is.EqualTo(original.OrderByClause.Clause)); + Assert.Multiple(() => + { + Assert.That(clone.SelectClause.Clause, Is.EqualTo(original.SelectClause.Clause)); + Assert.That(clone.FromClause.Clause, Is.EqualTo(original.FromClause.Clause)); + Assert.That(clone.WhereClause.Clause, Is.EqualTo(original.WhereClause.Clause)); + Assert.That(clone.OrderByClause.Clause, Is.EqualTo(original.OrderByClause.Clause)); + }); } [Test] @@ -1150,9 +1234,12 @@ public class QueryBreakdownTests // Act clone.WhereClause.Clause = "Active = 1"; - // Assert - Assert.That(original.WhereClause.Clause, Is.EqualTo(string.Empty)); - Assert.That(clone.WhereClause.Clause, Is.EqualTo("Active = 1")); + Assert.Multiple(() => + { + // Assert + Assert.That(original.WhereClause.Clause, Is.EqualTo(string.Empty)); + Assert.That(clone.WhereClause.Clause, Is.EqualTo("Active = 1")); + }); } #endregion @@ -1202,9 +1289,12 @@ public class QueryBreakdownTests // Act var query = QueryBreakdown.Parse(sql); - // Assert - Assert.That(query.SelectClause.Clause, Does.Contain("\"User Name\"")); - Assert.That(query.FromClause.Clause, Does.Contain("\"User Table\"")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Clause, Does.Contain("\"User Name\"")); + Assert.That(query.FromClause.Clause, Does.Contain("\"User Table\"")); + }); } [Test] @@ -1469,8 +1559,11 @@ public class QueryBreakdownTests // Assert Assert.That(query.SelectClause.Clause, Does.Contain("[Select]")); Assert.That(query.SelectClause.Clause, Does.Contain("[From]")); - Assert.That(query.SelectClause.Clause, Does.Contain("[Where]")); - Assert.That(query.FromClause.Clause, Does.Contain("[Order]")); + Assert.Multiple(() => + { + Assert.That(query.SelectClause.Clause, Does.Contain("[Where]")); + Assert.That(query.FromClause.Clause, Does.Contain("[Order]")); + }); } [Test] @@ -1863,9 +1956,12 @@ public class QueryBreakdownTests // Act query.AddSelectExpression(expr, "/* Primary key */"); - // Assert - Assert.That(query.SelectClause.Clause, Is.EqualTo("[Customers].[CustomerID]")); - Assert.That(query.SelectClause.Comment, Is.EqualTo("/* Primary key */")); + Assert.Multiple(() => + { + // Assert + Assert.That(query.SelectClause.Clause, Is.EqualTo("[Customers].[CustomerID]")); + Assert.That(query.SelectClause.Comment, Is.EqualTo("/* Primary key */")); + }); } [Test] diff --git a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/RecursiveCTETests.cs b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/RecursiveCTETests.cs index 0ef4663..b8766e4 100644 --- a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/RecursiveCTETests.cs +++ b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/RecursiveCTETests.cs @@ -33,9 +33,12 @@ public class RecursiveCTETests var isRecursive = withClause.IsRecursive; var hasRecursiveQuery = withClause.RecursiveQuery != null; - // Assert - Assert.That(isRecursive, Is.True); - Assert.That(hasRecursiveQuery, Is.True); + Assert.Multiple(() => + { + // Assert + Assert.That(isRecursive, Is.True); + Assert.That(hasRecursiveQuery, Is.True); + }); } [Test] @@ -143,10 +146,13 @@ public class RecursiveCTETests // Assert var keys = merged.Keys.ToList(); - Assert.That(keys.Any(k => k.Contains("AnchorStatus")), "Should include anchor query parameters"); - Assert.That(keys.Any(k => k.Contains("RecursiveLevel")), "Should include recursive query parameters"); - Assert.That(keys.Any(k => k.Contains("RecursiveStatus")), "Should include recurring query parameters"); - Assert.That(keys.Any(k => k.Contains("MainLimit")), "Should include main query parameters"); + Assert.Multiple(() => + { + Assert.That(keys.Any(k => k.Contains("AnchorStatus")), "Should include anchor query parameters"); + Assert.That(keys.Any(k => k.Contains("RecursiveLevel")), "Should include recursive query parameters"); + Assert.That(keys.Any(k => k.Contains("RecursiveStatus")), "Should include recurring query parameters"); + Assert.That(keys.Any(k => k.Contains("MainLimit")), "Should include main query parameters"); + }); } [Test] @@ -175,8 +181,11 @@ public class RecursiveCTETests // Assert var statusKey = merged.Keys.FirstOrDefault(k => k.Contains("Status") && !k.Contains('@') && !k.Contains('$')); - Assert.That(statusKey, Is.Not.Null); - Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence"); + Assert.Multiple(() => + { + Assert.That(statusKey, Is.Not.Null); + Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence"); + }); } #endregion diff --git a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/StatementExpressionParserTests.cs b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/StatementExpressionParserTests.cs index 0fbae25..2ac5d25 100644 --- a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/StatementExpressionParserTests.cs +++ b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/StatementExpressionParserTests.cs @@ -280,8 +280,11 @@ public class StatementExpressionParserTests // Act & Assert var ex = Assert.Throws(() => _parser.Parse(sql)); - Assert.That(ex.ParamName, Is.EqualTo("sqlStatement")); - Assert.That(ex.Message, Does.Contain("SQL statement cannot be null or empty")); + Assert.Multiple(() => + { + Assert.That(ex.ParamName, Is.EqualTo("sqlStatement")); + Assert.That(ex.Message, Does.Contain("SQL statement cannot be null or empty")); + }); } [Test] @@ -351,9 +354,12 @@ public class StatementExpressionParserTests // Act var success = _parser.TryParse(sql, out var result); - // Assert - Assert.That(success, Is.True); - Assert.That(result, Is.Not.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.True); + Assert.That(result, Is.Not.Null); + }); Assert.That(result, Is.InstanceOf()); } @@ -366,9 +372,12 @@ public class StatementExpressionParserTests // Act var success = _parser.TryParse(sql, out var result); - // Assert - Assert.That(success, Is.True); - Assert.That(result, Is.Not.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.True); + Assert.That(result, Is.Not.Null); + }); } [Test] @@ -380,9 +389,12 @@ public class StatementExpressionParserTests // Act var success = _parser.TryParse(sql, out var result); - // Assert - Assert.That(success, Is.True); - Assert.That(result, Is.Not.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.True); + Assert.That(result, Is.Not.Null); + }); Assert.That(result, Is.InstanceOf()); } @@ -395,9 +407,12 @@ public class StatementExpressionParserTests // Act var success = _parser.TryParse(sql, out var result); - // Assert - Assert.That(success, Is.False); - Assert.That(result, Is.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.False); + Assert.That(result, Is.Null); + }); } [Test] @@ -409,9 +424,12 @@ public class StatementExpressionParserTests // Act var success = _parser.TryParse(sql, out var result); - // Assert - Assert.That(success, Is.False); - Assert.That(result, Is.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.False); + Assert.That(result, Is.Null); + }); } [Test] @@ -423,9 +441,12 @@ public class StatementExpressionParserTests // Act var success = _parser.TryParse(sql, out var result); - // Assert - Assert.That(success, Is.False); - Assert.That(result, Is.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.False); + Assert.That(result, Is.Null); + }); } [Test] @@ -437,9 +458,12 @@ public class StatementExpressionParserTests // Act var success = _parser.TryParse(sql, out var result); - // Assert - Assert.That(success, Is.False); - Assert.That(result, Is.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.False); + Assert.That(result, Is.Null); + }); } [Test] @@ -451,10 +475,13 @@ public class StatementExpressionParserTests // Act var success = _parser.TryParse(sql, out var result, out var errorMessage); - // Assert - Assert.That(success, Is.True); - Assert.That(result, Is.Not.Null); - Assert.That(errorMessage, Is.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.True); + Assert.That(result, Is.Not.Null); + Assert.That(errorMessage, Is.Null); + }); } [Test] @@ -466,10 +493,13 @@ public class StatementExpressionParserTests // Act var success = _parser.TryParse(sql, out var result, out var errorMessage); - // Assert - Assert.That(success, Is.False); - Assert.That(result, Is.Null); - Assert.That(errorMessage, Is.Not.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.False); + Assert.That(result, Is.Null); + Assert.That(errorMessage, Is.Not.Null); + }); Assert.That(errorMessage, Does.Contain("SQL statement cannot be null or empty")); } @@ -482,10 +512,13 @@ public class StatementExpressionParserTests // Act var success = _parser.TryParse(sql, out var result, out var errorMessage); - // Assert - Assert.That(success, Is.False); - Assert.That(result, Is.Null); - Assert.That(errorMessage, Is.Not.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.False); + Assert.That(result, Is.Null); + Assert.That(errorMessage, Is.Not.Null); + }); Assert.That(errorMessage, Does.Contain("Invalid syntax")); } @@ -498,10 +531,13 @@ public class StatementExpressionParserTests // Act var success = _parser.TryParse(sql, out var result, out var errorMessage); - // Assert - Assert.That(success, Is.False); - Assert.That(result, Is.Null); - Assert.That(errorMessage, Is.Not.Null); + Assert.Multiple(() => + { + // Assert + Assert.That(success, Is.False); + Assert.That(result, Is.Null); + Assert.That(errorMessage, Is.Not.Null); + }); Assert.That(errorMessage, Does.Contain("not recognized")); } diff --git a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/StatementReaderTests.cs b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/StatementReaderTests.cs index af7bfd9..733e551 100644 --- a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/StatementReaderTests.cs +++ b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/StatementReaderTests.cs @@ -22,8 +22,11 @@ public class StatementReaderTests // Assert Assert.That(tokens, Is.Not.Empty); - Assert.That(tokens[0].Type, Is.EqualTo(TokenType.LeftParenthesis)); - Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Number)); - Assert.That(tokens[1].Value, Is.EqualTo("1")); + Assert.Multiple(() => + { + Assert.That(tokens[0].Type, Is.EqualTo(TokenType.LeftParenthesis)); + Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Number)); + Assert.That(tokens[1].Value, Is.EqualTo("1")); + }); } } diff --git a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/WithClauseTests.cs b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/WithClauseTests.cs index 514717e..a21b267 100644 --- a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/WithClauseTests.cs +++ b/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 -- 2.54.0 From 77eb5d8b458f5f4721f3d030457c4aca64982b9c Mon Sep 17 00:00:00 2001 From: Thom Lamb Date: Wed, 27 May 2026 12:01:34 -0500 Subject: [PATCH 3/5] chore(sonar): hoist constant arrays to static readonly fields in tests (CA1861) Two inline `new[] { ... }` literals inside TestCaseSource yield-returns get hoisted to `static readonly string[]` fields with descriptive names (`monthListValues`, `calendarRange`) matching the surrounding test-case identifiers. Avoids reconstructing the same array on each call. Only the test-file CA1861 sites are touched; the three production-code sites flagged for the same rule are out of scope for this branch and will land separately. Co-Authored-By: Claude Opus 4.7 (1M context) --- .../ExpressionTests/ExpressionFactoryFilterTests.cs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/ExpressionFactoryFilterTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/ExpressionFactoryFilterTests.cs index 25ce2f1..1fed843 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/ExpressionFactoryFilterTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/ExpressionFactoryFilterTests.cs @@ -6,6 +6,8 @@ namespace Strata.SqlTools.SqlBreakdown.Tests.ExpressionTests; public class ExpressionFactoryFilterTests : ExpressionTestsBase { private static readonly string[] values = new[] { "FY2019", "FY2020", "FY2021", "FY2022" }; + private static readonly string[] monthListValues = new[] { "01-2020" }; + private static readonly string[] calendarRange = new[] { "01/01/2019", "01/01/2023" }; private static IEnumerable FilterTestCases() { @@ -23,12 +25,12 @@ public class ExpressionFactoryFilterTests : ExpressionTestsBase ).SetName("DateListFilterFiscalYear_{m}"); yield return new TestCaseData( - new Filter(4, FilterType.List, new[] { "01-2020" }, Array.Empty(), DatePart.Month, false, 0, 0), + new Filter(4, FilterType.List, monthListValues, Array.Empty(), DatePart.Month, false, 0, 0), "DEPT.DISCHARGE_DATE >= '2020-01-01' AND DEPT.DISCHARGE_DATE < '2020-02-01'" ).SetName("MonthListFilter_{m}"); yield return new TestCaseData( - new Filter(4, FilterType.Calendar, new[] { "01/01/2019", "01/01/2023" }, Array.Empty(), DatePart.Month, false, 0, 0), + new Filter(4, FilterType.Calendar, calendarRange, Array.Empty(), DatePart.Month, false, 0, 0), "DEPT.DISCHARGE_DATE >= '2019-01-01' AND DEPT.DISCHARGE_DATE < '2023-01-01'" ).SetName("CalendarFilter_{m}"); -- 2.54.0 From 470cb009b90c49ac0377cad59758099b3fb1abb5 Mon Sep 17 00:00:00 2001 From: Thom Lamb Date: Wed, 27 May 2026 12:02:25 -0500 Subject: [PATCH 4/5] chore(sonar): cache JsonSerializerOptions in test fixture (CA1869) Promote the `new JsonSerializerOptions { Converters = { ... } }` instance that `OneTimeSetup` was constructing on each fixture run to a `private static readonly JsonSerializerOptions _jsonOptions` field, so the converter list isn't rebuilt per fixture. Strictly cosmetic here (OneTimeSetup runs once) but it's the change the analyzer wants and the field is the more idiomatic JsonSerializer pattern. Co-Authored-By: Claude Opus 4.7 (1M context) --- .../Strata.SqlTools.Rules.Tests/UnitTest1.cs | 20 ++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/tests/Strata.SqlTools.Rules.Tests/UnitTest1.cs b/tests/Strata.SqlTools.Rules.Tests/UnitTest1.cs index 382ed2d..a819250 100644 --- a/tests/Strata.SqlTools.Rules.Tests/UnitTest1.cs +++ b/tests/Strata.SqlTools.Rules.Tests/UnitTest1.cs @@ -11,20 +11,22 @@ public class Tests private static readonly Guid _pesDataTableGUID = new Guid("41639c8f-fecf-4449-b6e6-53f796c0c3e4"); private const string EncounterIDKey = "DimPatientEnEncounterID"; + private static readonly JsonSerializerOptions _jsonOptions = new() + { + Converters = + { + new HierarchicalDataConverter(), + new FlatDataConverter(), + new ObjectToInferredTypesConverter() + } + }; + public Dictionary? _encounterLookup; [OneTimeSetUp] public void OneTimeSetup() { - var allData = JsonSerializer.Deserialize>(File.ReadAllText(@"Data.json"), new JsonSerializerOptions - { - Converters = - { - new HierarchicalDataConverter(), - new FlatDataConverter(), - new ObjectToInferredTypesConverter() - } - }); + var allData = JsonSerializer.Deserialize>(File.ReadAllText(@"Data.json"), _jsonOptions); if (allData == null || allData.Count == 0) { -- 2.54.0 From 4fe9eb36e65044da49494fe41e7cefa7e8d18e2c Mon Sep 17 00:00:00 2001 From: Thom Lamb Date: Wed, 27 May 2026 12:14:13 -0500 Subject: [PATCH 5/5] =?UTF-8?q?chore(sonar):=20second=20sweep=20=E2=80=94?= =?UTF-8?q?=20catch=20.Length,=20Is.Not.Empty,=20and=20newly-exposed=20Mul?= =?UTF-8?q?tiple=20groups=20(NUnit2046,=20NUnit2045)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Re-runs `dotnet format analyzers --diagnostics NUnit2046 NUnit2045` after the Tier 2 Assert.Multiple wrap, which exposed: - `Has.Length.EqualTo(n)` rewrites for `string[]`/array `.Length` checks (the first pass only knew about `.Count`). - `Is.Not.Empty` rewrites for `Count, Is.GreaterThan(0)`. - A handful of new NUnit2045 groups that became wrappable once the initial Multiple blocks settled the surrounding indentation. Tests still 1180/1180 passing. Co-Authored-By: Claude Opus 4.7 (1M context) --- .../QueryCollectionAnalyzerTests.cs | 2 +- .../QueryValidatorTests.cs | 2 +- .../QueryBreakdownCollectionTests.cs | 6 +++--- .../PostgreSql/QueryBreakdownTests.cs | 2 +- .../PostgreSql/StatementReaderTests.cs | 8 +++---- .../QueryBreakdownCollectionTests.cs | 2 +- .../Snowflake/QueryBreakdownTests.cs | 21 +++++++++++-------- .../ExpressionTests/DateFunctionTests.cs | 2 +- .../ExpressionFactoryFilterTests.cs | 2 +- .../GenericColumnExpressionTests.cs | 5 ++--- .../JsonTokenReaderTests.cs | 7 +++++-- .../SqlBreakdownCollectionCreateTests.cs | 2 +- .../SqlBreakdownCollectionDeleteTests.cs | 2 +- .../SqlBreakdownCollectionSelectTests.cs | 2 +- .../SqlBreakdownCollectionTransactionTests.cs | 2 +- .../SqlBreakdownCollectionUpdateTests.cs | 2 +- .../QueryBreakdownCollectionTests.cs | 2 +- .../SqlServer/QueryBreakdownTests.cs | 18 ++++++++++------ 18 files changed, 50 insertions(+), 39 deletions(-) diff --git a/tests/Strata.SqlTools.LinqToSql.Tests/QueryCollectionAnalyzerTests.cs b/tests/Strata.SqlTools.LinqToSql.Tests/QueryCollectionAnalyzerTests.cs index 2565e5a..0f2b2df 100644 --- a/tests/Strata.SqlTools.LinqToSql.Tests/QueryCollectionAnalyzerTests.cs +++ b/tests/Strata.SqlTools.LinqToSql.Tests/QueryCollectionAnalyzerTests.cs @@ -406,7 +406,7 @@ public class QueryCollectionAnalyzerTests var similar = analyzer.FindSimilarQueries(0.5); // Lower threshold for testing // Assert - Assert.That(similar.Count, Is.GreaterThan(0)); + Assert.That(similar, Is.Not.Empty); } [Test] diff --git a/tests/Strata.SqlTools.LinqToSql.Tests/QueryValidatorTests.cs b/tests/Strata.SqlTools.LinqToSql.Tests/QueryValidatorTests.cs index 3c49fd0..ec905ae 100644 --- a/tests/Strata.SqlTools.LinqToSql.Tests/QueryValidatorTests.cs +++ b/tests/Strata.SqlTools.LinqToSql.Tests/QueryValidatorTests.cs @@ -550,7 +550,7 @@ public class QueryValidatorTests // Assert Assert.That(validator, Is.Not.Null); - Assert.That(validator.Issues.Count, Is.GreaterThan(0)); + Assert.That(validator.Issues, Is.Not.Empty); } #endregion diff --git a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownCollectionTests.cs b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownCollectionTests.cs index 0d48c3e..8d3e0d9 100644 --- a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownCollectionTests.cs +++ b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownCollectionTests.cs @@ -39,7 +39,7 @@ public class QueryBreakdownCollectionTests _collection.Add(query); // Assert - Assert.That(_collection.Count, Is.GreaterThan(0)); + Assert.That(_collection, Is.Not.Empty); } [Test] @@ -186,7 +186,7 @@ public class QueryBreakdownCollectionTests { // Assert Assert.That(result, Is.True); - Assert.That(_collection.Count, Is.GreaterThan(0)); + Assert.That(_collection, Is.Not.Empty); }); } @@ -206,7 +206,7 @@ public class QueryBreakdownCollectionTests { // Assert Assert.That(result, Is.True); - Assert.That(_collection.Count, Is.GreaterThan(0)); + Assert.That(_collection, Is.Not.Empty); }); } diff --git a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownTests.cs b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownTests.cs index 9d10aae..7191785 100644 --- a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownTests.cs +++ b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/QueryBreakdownTests.cs @@ -182,7 +182,7 @@ public class QueryBreakdownTests // Assert // The @ prefix is stripped - Assert.That(queryBreakdown.Parameters.Count, Is.GreaterThan(0)); + Assert.That(queryBreakdown.Parameters, Is.Not.Empty); } #endregion diff --git a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/StatementReaderTests.cs b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/StatementReaderTests.cs index c0d1449..285ec9a 100644 --- a/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/StatementReaderTests.cs +++ b/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/StatementReaderTests.cs @@ -95,7 +95,7 @@ public class StatementReaderTests } // Assert - Assert.That(tokens.Count, Is.GreaterThan(0)); + Assert.That(tokens, Is.Not.Empty); var paramTokens = tokens.Where(t => t.Type == TokenType.Parameter).ToList(); Assert.That(paramTokens, Has.Count.EqualTo(2)); Assert.Multiple(() => @@ -173,7 +173,7 @@ public class StatementReaderTests } // Assert - Assert.That(tokens.Count, Is.GreaterThan(0)); + Assert.That(tokens, Is.Not.Empty); } [Test] @@ -191,7 +191,7 @@ public class StatementReaderTests } // Assert - Assert.That(tokens.Count, Is.GreaterThan(0)); + Assert.That(tokens, Is.Not.Empty); } [Test] @@ -229,6 +229,6 @@ public class StatementReaderTests // Assert var numberTokens = tokens.Where(t => t.Type == TokenType.Number).ToList(); - Assert.That(numberTokens.Count, Is.GreaterThan(0)); + Assert.That(numberTokens, Is.Not.Empty); } } diff --git a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownCollectionTests.cs b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownCollectionTests.cs index a476455..304a86d 100644 --- a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownCollectionTests.cs +++ b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownCollectionTests.cs @@ -247,7 +247,7 @@ public class QueryBreakdownCollectionTests var report = _collection.GetParameterUsageReport().ToList(); // Assert - Assert.That(report.Count, Is.GreaterThan(0)); + Assert.That(report, Is.Not.Empty); var userIdReport = report.FirstOrDefault(r => r.ParameterName == "UserId"); Assert.That(userIdReport, Is.Not.Null); Assert.That(userIdReport?.UsedInQueryCount, Is.EqualTo(2)); diff --git a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownTests.cs b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownTests.cs index 090d8da..acbbc08 100644 --- a/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownTests.cs +++ b/tests/Strata.SqlTools.Snowflake.Tests/Snowflake/QueryBreakdownTests.cs @@ -127,7 +127,7 @@ public class QueryBreakdownTests // Verify 4-space Snowflake indentation var lines = sql.Split(separator, StringSplitOptions.RemoveEmptyEntries); var indentedLines = lines.Where(l => l.StartsWith(" ")).ToList(); - Assert.That(indentedLines.Count, Is.GreaterThan(0)); + Assert.That(indentedLines, Is.Not.Empty); } [Test] @@ -306,10 +306,13 @@ public class QueryBreakdownTests Assert.That(withIndex, Is.GreaterThan(-1)); Assert.That(mainSelectIndex, Is.GreaterThan(-1)); }); - Assert.That(withIndex, Is.LessThan(mainSelectIndex)); + Assert.Multiple(() => + { + Assert.That(withIndex, Is.LessThan(mainSelectIndex)); - // Assert - Verify CTE definition - Assert.That(sql, Does.Contain("PRODUCT_TOTALS")); + // Assert - Verify CTE definition + Assert.That(sql, Does.Contain("PRODUCT_TOTALS")); + }); Assert.That(sql, Does.Contain("AS")); Assert.That(sql, Does.Contain("PRODUCT_ID")); Assert.That(sql, Does.Contain("TOTAL_QUANTITY")); @@ -457,7 +460,7 @@ public class QueryBreakdownTests // Assert // Main query value should win var keys = merged.Keys.Where(k => k.Contains("QueryLimit")).ToList(); - Assert.That(keys.Count, Is.GreaterThan(0)); + Assert.That(keys, Is.Not.Empty); // All QueryLimit entries should be 100 (main query's value) foreach (var key in keys) { @@ -614,7 +617,7 @@ public class QueryBreakdownTests var queryBreakdown = QueryBreakdown.Parse(sql, false); // Assert - Assert.That(queryBreakdown.Parameters.Count, Is.GreaterThan(0)); + Assert.That(queryBreakdown.Parameters, Is.Not.Empty); } [Test] @@ -1070,7 +1073,7 @@ public class QueryBreakdownTests // Assert // Base class normalizes to @, but Snowflake might handle differently - Assert.That(queryBreakdown.Parameters.Count, Is.GreaterThan(0)); + Assert.That(queryBreakdown.Parameters, Is.Not.Empty); } #endregion @@ -1188,7 +1191,7 @@ public class QueryBreakdownTests // Assert - Snowflake should use 4-space indent, base uses 5-space var snowflakeLines = snowflakeSql.Split(separator, StringSplitOptions.RemoveEmptyEntries); var snowflakeIndentedLines = snowflakeLines.Where(l => l.StartsWith(" ") && !l.StartsWith(" ")).ToList(); - Assert.That(snowflakeIndentedLines.Count, Is.GreaterThan(0), "Snowflake should use 4-space indentation"); + Assert.That(snowflakeIndentedLines, Is.Not.Empty, "Snowflake should use 4-space indentation"); } #endregion @@ -1407,7 +1410,7 @@ public class QueryBreakdownTests // Verify Snowflake-style formatting (4-space indentation) var lines = snowflakeSql.Split(separator, StringSplitOptions.RemoveEmptyEntries); var indentedLines = lines.Where(l => l.StartsWith(" ")).ToList(); - Assert.That(indentedLines.Count, Is.GreaterThan(0), "Should have Snowflake-style indentation"); + Assert.That(indentedLines, Is.Not.Empty, "Should have Snowflake-style indentation"); } [Test] diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/DateFunctionTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/DateFunctionTests.cs index fc24bdd..346c830 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/DateFunctionTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/DateFunctionTests.cs @@ -27,7 +27,7 @@ public class DateFunctionTests : ExpressionTestsBase { var sql = (string)result; Assert.That(sql, Is.Not.Null); - Assert.That(sql.Length, Is.GreaterThan(0)); + Assert.That(sql, Is.Not.Empty); Assert.That(sql, Is.EqualTo("DATE_TRUNC('month', DATEADD('month', 6, PES.DISCHARGE_DATE))")); return true; } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/ExpressionFactoryFilterTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/ExpressionFactoryFilterTests.cs index 1fed843..11222be 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/ExpressionFactoryFilterTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/ExpressionFactoryFilterTests.cs @@ -52,7 +52,7 @@ public class ExpressionFactoryFilterTests : ExpressionTestsBase // Assert Assert.That(result, Is.Not.Null); - Assert.That(result.Length, Is.GreaterThan(0)); + Assert.That(result, Is.Not.Empty); Assert.That(result, Is.EqualTo(expectedSql)); } } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/GenericColumnExpressionTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/GenericColumnExpressionTests.cs index 36947a4..e774296 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/GenericColumnExpressionTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/ExpressionTests/GenericColumnExpressionTests.cs @@ -65,9 +65,8 @@ public class GenericColumnExpressionTests : ExpressionTestsBase Assertions = result => { var results = (Dictionary)result; - Assert.That(results["priceCondition"], Does.Contain("Price")); - Assert.That(results["priceCondition"], Does.Contain("100")); - Assert.That(results["categoryCondition"], Does.Contain("Category")); + Assert.That(results["priceCondition"], Does.Contain("Price")); Assert.Multiple(() => { Assert.That(results["priceCondition"], Does.Contain("100")); + Assert.That(results["categoryCondition"], Does.Contain("Category")); }); Assert.That(results["categoryCondition"], Does.Contain("Electronics")); return true; } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/JsonTokenReaderTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/JsonTokenReaderTests.cs index 856d3d5..8fc95f3 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/JsonTokenReaderTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/JsonTokenReaderTests.cs @@ -57,8 +57,11 @@ public class JsonTokenReaderTests Assert.That(tokens[tokenIndex].Type, Is.EqualTo(JsonTokenType.Number)); Assert.That(tokens[tokenIndex++].Value, Is.EqualTo("1")); }); - Assert.That(tokens[tokenIndex].Type, Is.EqualTo(JsonTokenType.Number)); - Assert.That(tokens[tokenIndex++].Value, Is.EqualTo("2")); + Assert.Multiple(() => + { + Assert.That(tokens[tokenIndex].Type, Is.EqualTo(JsonTokenType.Number)); + Assert.That(tokens[tokenIndex++].Value, Is.EqualTo("2")); + }); Assert.That(tokens[tokenIndex].Type, Is.EqualTo(JsonTokenType.Number)); Assert.That(tokens[tokenIndex++].Value, Is.EqualTo("3")); Assert.That(tokens[tokenIndex].Type, Is.EqualTo(JsonTokenType.Number)); diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCreateTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCreateTests.cs index a88ed5e..35d9750 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCreateTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionCreateTests.cs @@ -80,7 +80,7 @@ public class SqlBreakdownCollectionCreateTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.GreaterThanOrEqualTo(1)); + Assert.That(collection, Is.Not.Empty); Assert.That(collection.GetRawStatementAt(0), Does.Contain("CREATE PROCEDURE")); } } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDeleteTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDeleteTests.cs index 38370cd..22c3572 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDeleteTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionDeleteTests.cs @@ -71,7 +71,7 @@ public class SqlBreakdownCollectionDeleteTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.GreaterThanOrEqualTo(1)); + Assert.That(collection, Is.Not.Empty); Assert.That(collection.GetRawStatementAt(0), Does.Contain("DELETE Orders")); Assert.That(collection.GetRawStatementAt(0), Does.Contain("INNER JOIN")); } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSelectTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSelectTests.cs index 6dab82b..24b6e45 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSelectTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionSelectTests.cs @@ -58,7 +58,7 @@ public class SqlBreakdownCollectionSelectTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.GreaterThanOrEqualTo(1)); + Assert.That(collection, Is.Not.Empty); Assert.That(collection.GetRawStatementAt(0), Does.Contain("WITH UserOrders AS")); } diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionTransactionTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionTransactionTests.cs index 00909e4..8aa47a2 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionTransactionTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionTransactionTests.cs @@ -29,7 +29,7 @@ public class SqlBreakdownCollectionTransactionTests : SqlBreakdownCollectionTest collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.GreaterThanOrEqualTo(1)); + Assert.That(collection, Is.Not.Empty); var statement = collection.GetRawStatementAt(0); Assert.That(statement, Does.Contain("BEGIN TRANSACTION")); Assert.That(statement, Does.Contain("COMMIT")); diff --git a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionUpdateTests.cs b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionUpdateTests.cs index 430d8b8..45429b9 100644 --- a/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionUpdateTests.cs +++ b/tests/Strata.SqlTools.SqlBreakdown.Tests/SqlBreakdownCollectionTests/SqlBreakdownCollectionUpdateTests.cs @@ -80,7 +80,7 @@ public class SqlBreakdownCollectionUpdateTests : SqlBreakdownCollectionTestBase collection.ParseBatch(batchSql); // Assert - Assert.That(collection.Count, Is.GreaterThanOrEqualTo(1)); + Assert.That(collection, Is.Not.Empty); Assert.That(collection.GetRawStatementAt(0), Does.Contain("UPDATE Orders")); Assert.That(collection.GetRawStatementAt(0), Does.Contain("JOIN")); } diff --git a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownCollectionTests.cs b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownCollectionTests.cs index 660c016..b43f595 100644 --- a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownCollectionTests.cs +++ b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownCollectionTests.cs @@ -360,7 +360,7 @@ public class QueryBreakdownCollectionTests var report = _collection.GetParameterUsageReport().ToList(); // Assert - Assert.That(report.Count, Is.GreaterThan(0)); + Assert.That(report, Is.Not.Empty); var userIdReport = report.FirstOrDefault(r => r.ParameterName == "UserId"); Assert.That(userIdReport, Is.Not.Null); Assert.That(userIdReport?.UsedInQueryCount, Is.EqualTo(2)); diff --git a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownTests.cs b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownTests.cs index 0ec2a87..d4390bb 100644 --- a/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownTests.cs +++ b/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/QueryBreakdownTests.cs @@ -29,9 +29,12 @@ public class QueryBreakdownTests Assert.That(query.FinishClauses, Is.Not.Null); Assert.That(query.WithClauses, Is.Not.Null); }); - Assert.That(query.WithClauses, Is.Empty); - Assert.That(query.Parameters, Is.Not.Null); - Assert.That(query.ParameterList, Is.Not.Null); + Assert.Multiple(() => + { + Assert.That(query.WithClauses, Is.Empty); + Assert.That(query.Parameters, Is.Not.Null); + Assert.That(query.ParameterList, Is.Not.Null); + }); } [Test] @@ -778,10 +781,13 @@ public class QueryBreakdownTests Assert.That(withIndex, Is.GreaterThan(-1)); Assert.That(mainSelectIndex, Is.GreaterThan(-1)); }); - Assert.That(withIndex, Is.LessThan(mainSelectIndex)); + Assert.Multiple(() => + { + Assert.That(withIndex, Is.LessThan(mainSelectIndex)); - // Assert - Verify CTE definition - Assert.That(sql, Does.Contain("ProductTotals")); + // Assert - Verify CTE definition + Assert.That(sql, Does.Contain("ProductTotals")); + }); Assert.That(sql, Does.Contain("AS")); Assert.That(sql, Does.Contain("ProductID")); Assert.That(sql, Does.Contain("TotalQuantity")); -- 2.54.0