chore(sonar): wrap independent assertions in Assert.Multiple (NUnit2045)
Driven by `dotnet format analyzers --diagnostics NUnit2045`. The fixer
groups consecutive independent `Assert.That(...)` calls into
`Assert.Multiple(() => { ... })`, so a failing assertion no longer
short-circuits the block — every failure inside the group is reported,
which gives much better diagnostics on multi-property tests.
Audit confirmed no Assert.Throws / Assert.Fail / Assert.Catch / Assert.Pass
/ Assert.DoesNotThrow got pulled inside a Multiple block (those need to
short-circuit). All 1180 tests pass.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Thom Lamb
co-authored by
Claude Opus 4.7
Claude Opus 4.7
parent
505ada5017
commit
67512d23e1
@@ -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
|
||||
|
||||
@@ -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"));
|
||||
}
|
||||
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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<DateTime>().Count();
|
||||
var decimalValues = merged.Values.OfType<decimal>().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<QueryBreakdown>());
|
||||
}
|
||||
|
||||
@@ -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<QueryBreakdown>(), "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<QueryBreakdown>());
|
||||
}
|
||||
|
||||
@@ -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<QueryBreakdown>());
|
||||
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<QueryBreakdown>());
|
||||
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"));
|
||||
}
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -34,8 +34,11 @@ public class StatementExpressionParserTests
|
||||
|
||||
// Assert
|
||||
Assert.That(result, Is.Not.Null);
|
||||
Assert.That(result, Is.InstanceOf<NumberLiteralExpression>());
|
||||
Assert.That(((NumberLiteralExpression)result).Value, Is.EqualTo(42));
|
||||
Assert.Multiple(() =>
|
||||
{
|
||||
Assert.That(result, Is.InstanceOf<NumberLiteralExpression>());
|
||||
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<NumberLiteralExpression>());
|
||||
Assert.That(((NumberLiteralExpression)result).Value, Is.EqualTo(3.14m));
|
||||
Assert.Multiple(() =>
|
||||
{
|
||||
Assert.That(result, Is.InstanceOf<NumberLiteralExpression>());
|
||||
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<ColumnExpression>());
|
||||
Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("CUSTOMER_ID"));
|
||||
Assert.Multiple(() =>
|
||||
{
|
||||
Assert.That(result, Is.InstanceOf<ColumnExpression>());
|
||||
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<ColumnExpression>());
|
||||
Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("CUSTOMER_ID"));
|
||||
Assert.Multiple(() =>
|
||||
{
|
||||
Assert.That(result, Is.InstanceOf<ColumnExpression>());
|
||||
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<ColumnExpression>());
|
||||
Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("ORDER_TOTAL"));
|
||||
Assert.Multiple(() =>
|
||||
{
|
||||
Assert.That(result, Is.InstanceOf<ColumnExpression>());
|
||||
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<ColumnExpression>());
|
||||
Assert.That(((ColumnExpression)result).ColumnName, Is.EqualTo("NET_REVENUE_USD_2024"));
|
||||
Assert.Multiple(() =>
|
||||
{
|
||||
Assert.That(result, Is.InstanceOf<ColumnExpression>());
|
||||
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
|
||||
|
||||
@@ -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"));
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user