Skip to content

Test Improvements #764

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 30 commits into
base: main
Choose a base branch
from
Open

Test Improvements #764

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
30 commits
Select commit Hold shift + click to select a range
9519fc7
Basic Fixes and Add user secrets for db connection.
faddiv Nov 29, 2024
4e748e1
Testing improvement: Eliminate direct testing of CompileLimit
faddiv Nov 29, 2024
7d23e22
Improved Delete tests
faddiv Nov 30, 2024
d3355a1
Improved ExecutionTests
faddiv Nov 30, 2024
e9df38e
Refactor DefineTest
faddiv Nov 30, 2024
3631797
Improved GeneralTests part 1
faddiv Nov 30, 2024
0ba9bf3
Improved GeneralTests part 2
faddiv Dec 1, 2024
8a7996e
Imporved InsertTests part 1
faddiv Dec 1, 2024
8e97da4
Imporved InsertTests part 2
faddiv Dec 4, 2024
8b9d26d
Move MySql and SqlLite execution tests into subdir.
faddiv Dec 4, 2024
67ab7ad
Move QueryFactoryExtensions into infra
faddiv Dec 4, 2024
047ec4d
Imporved SelectTests part 1
faddiv Dec 4, 2024
d009e75
Imporved SelectTests part 2
faddiv Dec 8, 2024
1b3d430
Imporved SelectTests part 3
faddiv Dec 22, 2024
1496dbd
Improved UpdateTests
faddiv Dec 22, 2024
132e8b9
Improved WhereTests
faddiv Dec 22, 2024
1de8e2d
Organize code.
faddiv Dec 22, 2024
21bf41f
Improve WhiteListing coverage.
faddiv Dec 22, 2024
6f70580
Improve AggregateTests
faddiv Dec 22, 2024
b9553b6
UnsafeLiteral in conditions
faddiv Dec 22, 2024
b9e3ed7
Binding tests
faddiv Dec 23, 2024
3c26169
Eliminate old TestCompilersContainer
faddiv Dec 24, 2024
7d69200
Add Select benchmark.
faddiv Dec 24, 2024
fdbe84d
Add different benchmarks and tests
faddiv Dec 25, 2024
441a619
Global usings
faddiv Dec 25, 2024
817c514
Remove direct Limit test from Firebird
faddiv Dec 25, 2024
39c9719
Remove direct Limit test from Oracle and SqlServer
faddiv Dec 25, 2024
d621992
Revert Benchmarks
faddiv Sep 30, 2025
8a9d551
Merge branch 'faddiv/main' into faddiv/test-improvements
faddiv Sep 30, 2025
bb58430
Cleanup
faddiv Sep 30, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
173 changes: 128 additions & 45 deletions QueryBuilder.Tests/AggregateTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,92 +1,175 @@
using SqlKata.Compilers;
using SqlKata.Tests.Infrastructure;
using Xunit;

namespace SqlKata.Tests
{
public class AggregateTests : TestSupport
{
[Fact]
public void Count()
[Theory]
[InlineData(EngineCodes.Firebird, "SELECT COUNT(*) AS \"COUNT\" FROM \"A\"")]
[InlineData(EngineCodes.MySql, "SELECT COUNT(*) AS `count` FROM `A`")]
[InlineData(EngineCodes.Oracle, "SELECT COUNT(*) \"count\" FROM \"A\"")]
[InlineData(EngineCodes.PostgreSql, "SELECT COUNT(*) AS \"count\" FROM \"A\"")]
[InlineData(EngineCodes.Sqlite, "SELECT COUNT(*) AS \"count\" FROM \"A\"")]
[InlineData(EngineCodes.SqlServer, "SELECT COUNT(*) AS [count] FROM [A]")]
public void Count(string engine, string query)
{
var query = new Query("A").AsCount();
var q = new Query("A").AsCount();

var c = Compile(query);
var result = CompileFor(engine, q);

Assert.Equal("SELECT COUNT(*) AS [count] FROM [A]", c[EngineCodes.SqlServer]);
Assert.Equal("SELECT COUNT(*) AS `count` FROM `A`", c[EngineCodes.MySql]);
Assert.Equal("SELECT COUNT(*) AS \"count\" FROM \"A\"", c[EngineCodes.PostgreSql]);
Assert.Equal("SELECT COUNT(*) AS \"COUNT\" FROM \"A\"", c[EngineCodes.Firebird]);
Assert.Equal(query, result.ToString());
}

[Fact]
public void CountMultipleColumns()
[Theory]
[InlineData(EngineCodes.Firebird,
"SELECT COUNT(*) AS \"COUNT\" FROM (SELECT 1 FROM \"A\" WHERE \"COLUMNA\" IS NOT NULL AND \"COLUMNB\" IS NOT NULL) AS \"COUNTQUERY\"")]
[InlineData(EngineCodes.MySql,
"SELECT COUNT(*) AS `count` FROM (SELECT 1 FROM `A` WHERE `ColumnA` IS NOT NULL AND `ColumnB` IS NOT NULL) AS `countQuery`")]
[InlineData(EngineCodes.Oracle,
"SELECT COUNT(*) \"count\" FROM (SELECT 1 FROM \"A\" WHERE \"ColumnA\" IS NOT NULL AND \"ColumnB\" IS NOT NULL) \"countQuery\"")]
[InlineData(EngineCodes.PostgreSql,
"SELECT COUNT(*) AS \"count\" FROM (SELECT 1 FROM \"A\" WHERE \"ColumnA\" IS NOT NULL AND \"ColumnB\" IS NOT NULL) AS \"countQuery\"")]
[InlineData(EngineCodes.Sqlite,
"SELECT COUNT(*) AS \"count\" FROM (SELECT 1 FROM \"A\" WHERE \"ColumnA\" IS NOT NULL AND \"ColumnB\" IS NOT NULL) AS \"countQuery\"")]
[InlineData(EngineCodes.SqlServer,
"SELECT COUNT(*) AS [count] FROM (SELECT 1 FROM [A] WHERE [ColumnA] IS NOT NULL AND [ColumnB] IS NOT NULL) AS [countQuery]")]
public void CountMultipleColumns(string engine, string query)
{
var query = new Query("A").AsCount(new[] { "ColumnA", "ColumnB" });
var q = new Query("A").AsCount(["ColumnA", "ColumnB"]);

var c = Compile(query);
var result = CompileFor(engine, q);

Assert.Equal("SELECT COUNT(*) AS [count] FROM (SELECT 1 FROM [A] WHERE [ColumnA] IS NOT NULL AND [ColumnB] IS NOT NULL) AS [countQuery]", c[EngineCodes.SqlServer]);
Assert.Equal(query, result.ToString());
}

[Fact]
public void DistinctCount()
[Theory]
[InlineData(EngineCodes.Firebird,
"SELECT COUNT(*) AS \"COUNT\" FROM (SELECT DISTINCT * FROM \"A\") AS \"COUNTQUERY\"")]
[InlineData(EngineCodes.MySql, "SELECT COUNT(*) AS `count` FROM (SELECT DISTINCT * FROM `A`) AS `countQuery`")]
[InlineData(EngineCodes.Oracle, "SELECT COUNT(*) \"count\" FROM (SELECT DISTINCT * FROM \"A\") \"countQuery\"")]
[InlineData(EngineCodes.PostgreSql,
"SELECT COUNT(*) AS \"count\" FROM (SELECT DISTINCT * FROM \"A\") AS \"countQuery\"")]
[InlineData(EngineCodes.Sqlite,
"SELECT COUNT(*) AS \"count\" FROM (SELECT DISTINCT * FROM \"A\") AS \"countQuery\"")]
[InlineData(EngineCodes.SqlServer,
"SELECT COUNT(*) AS [count] FROM (SELECT DISTINCT * FROM [A]) AS [countQuery]")]
public void DistinctCount(string engine, string query)
{
var query = new Query("A").Distinct().AsCount();
var q = new Query("A").Distinct().AsCount();

var c = Compile(query);
var result = CompileFor(engine, q);

Assert.Equal("SELECT COUNT(*) AS [count] FROM (SELECT DISTINCT * FROM [A]) AS [countQuery]", c[EngineCodes.SqlServer]);
Assert.Equal(query, result.ToString());
}

[Fact]
public void DistinctCountMultipleColumns()
[Theory]
[InlineData(EngineCodes.Firebird,
"SELECT COUNT(*) AS \"COUNT\" FROM (SELECT DISTINCT \"COLUMNA\", \"COLUMNB\" FROM \"A\") AS \"COUNTQUERY\"")]
[InlineData(EngineCodes.MySql,
"SELECT COUNT(*) AS `count` FROM (SELECT DISTINCT `ColumnA`, `ColumnB` FROM `A`) AS `countQuery`")]
[InlineData(EngineCodes.Oracle,
"SELECT COUNT(*) \"count\" FROM (SELECT DISTINCT \"ColumnA\", \"ColumnB\" FROM \"A\") \"countQuery\"")]
[InlineData(EngineCodes.PostgreSql,
"SELECT COUNT(*) AS \"count\" FROM (SELECT DISTINCT \"ColumnA\", \"ColumnB\" FROM \"A\") AS \"countQuery\"")]
[InlineData(EngineCodes.Sqlite,
"SELECT COUNT(*) AS \"count\" FROM (SELECT DISTINCT \"ColumnA\", \"ColumnB\" FROM \"A\") AS \"countQuery\"")]
[InlineData(EngineCodes.SqlServer,
"SELECT COUNT(*) AS [count] FROM (SELECT DISTINCT [ColumnA], [ColumnB] FROM [A]) AS [countQuery]")]
public void DistinctCountMultipleColumns(string engine, string query)
{
var query = new Query("A").Distinct().AsCount(new[] { "ColumnA", "ColumnB" });
var q = new Query("A").Distinct().AsCount(new[] { "ColumnA", "ColumnB" });

var c = Compile(query);
var result = CompileFor(engine, q);

Assert.Equal("SELECT COUNT(*) AS [count] FROM (SELECT DISTINCT [ColumnA], [ColumnB] FROM [A]) AS [countQuery]", c[EngineCodes.SqlServer]);
Assert.Equal(query, result.ToString());
}

[Fact]
public void Average()
[Theory]
[InlineData(EngineCodes.Firebird,
"SELECT AVG(\"TTL\") AS \"AVG\" FROM \"A\"")]
[InlineData(EngineCodes.MySql,
"SELECT AVG(`TTL`) AS `avg` FROM `A`")]
[InlineData(EngineCodes.Oracle,
"SELECT AVG(\"TTL\") \"avg\" FROM \"A\"")]
[InlineData(EngineCodes.PostgreSql,
"SELECT AVG(\"TTL\") AS \"avg\" FROM \"A\"")]
[InlineData(EngineCodes.Sqlite,
"SELECT AVG(\"TTL\") AS \"avg\" FROM \"A\"")]
[InlineData(EngineCodes.SqlServer,
"SELECT AVG([TTL]) AS [avg] FROM [A]")]
public void Average(string engine, string query)
{
var query = new Query("A").AsAverage("TTL");
var q = new Query("A").AsAverage("TTL");

var c = Compile(query);
var result = CompileFor(engine, q);

Assert.Equal("SELECT AVG([TTL]) AS [avg] FROM [A]", c[EngineCodes.SqlServer]);
Assert.Equal(query, result.ToString());
}

[Fact]
public void Sum()
[Theory]
[InlineData(EngineCodes.Firebird,
"SELECT SUM(\"PACKETSDROPPED\") AS \"SUM\" FROM \"A\"")]
[InlineData(EngineCodes.MySql,
"SELECT SUM(`PacketsDropped`) AS `sum` FROM `A`")]
[InlineData(EngineCodes.Oracle,
"SELECT SUM(\"PacketsDropped\") \"sum\" FROM \"A\"")]
[InlineData(EngineCodes.PostgreSql,
"SELECT SUM(\"PacketsDropped\") AS \"sum\" FROM \"A\"")]
[InlineData(EngineCodes.Sqlite,
"SELECT SUM(\"PacketsDropped\") AS \"sum\" FROM \"A\"")]
[InlineData(EngineCodes.SqlServer,
"SELECT SUM([PacketsDropped]) AS [sum] FROM [A]")]
public void Sum(string engine, string query)
{
var query = new Query("A").AsSum("PacketsDropped");
var q = new Query("A").AsSum("PacketsDropped");

var c = Compile(query);
var result = CompileFor(engine, q);

Assert.Equal("SELECT SUM([PacketsDropped]) AS [sum] FROM [A]", c[EngineCodes.SqlServer]);
Assert.Equal(query, result.ToString());
}

[Fact]
public void Max()
[Theory]
[InlineData(EngineCodes.Firebird,
"SELECT MAX(\"LATENCYMS\") AS \"MAX\" FROM \"A\"")]
[InlineData(EngineCodes.MySql,
"SELECT MAX(`LatencyMs`) AS `max` FROM `A`")]
[InlineData(EngineCodes.Oracle,
"SELECT MAX(\"LatencyMs\") \"max\" FROM \"A\"")]
[InlineData(EngineCodes.PostgreSql,
"SELECT MAX(\"LatencyMs\") AS \"max\" FROM \"A\"")]
[InlineData(EngineCodes.Sqlite,
"SELECT MAX(\"LatencyMs\") AS \"max\" FROM \"A\"")]
[InlineData(EngineCodes.SqlServer,
"SELECT MAX([LatencyMs]) AS [max] FROM [A]")]
public void Max(string engine, string query)
{
var query = new Query("A").AsMax("LatencyMs");
var q = new Query("A").AsMax("LatencyMs");

var c = Compile(query);
var result = CompileFor(engine, q);

Assert.Equal("SELECT MAX([LatencyMs]) AS [max] FROM [A]", c[EngineCodes.SqlServer]);
Assert.Equal(query, result.ToString());
}

[Fact]
public void Min()
[Theory]
[InlineData(EngineCodes.Firebird,
"SELECT MIN(\"LATENCYMS\") AS \"MIN\" FROM \"A\"")]
[InlineData(EngineCodes.MySql,
"SELECT MIN(`LatencyMs`) AS `min` FROM `A`")]
[InlineData(EngineCodes.Oracle,
"SELECT MIN(\"LatencyMs\") \"min\" FROM \"A\"")]
[InlineData(EngineCodes.PostgreSql,
"SELECT MIN(\"LatencyMs\") AS \"min\" FROM \"A\"")]
[InlineData(EngineCodes.Sqlite,
"SELECT MIN(\"LatencyMs\") AS \"min\" FROM \"A\"")]
[InlineData(EngineCodes.SqlServer,
"SELECT MIN([LatencyMs]) AS [min] FROM [A]")]
public void Min(string engine, string query)
{
var query = new Query("A").AsMin("LatencyMs");
var q = new Query("A").AsMin("LatencyMs");

var c = Compile(query);
var result = CompileFor(engine, q);

Assert.Equal("SELECT MIN([LatencyMs]) AS [min] FROM [A]", c[EngineCodes.SqlServer]);
Assert.Equal(query, result.ToString());
}
}
}
Loading