chore: initial git load of code space

testContainers/Strata.SqlTools.PostgreSql.TestContainers/PostgreSqlQueryBreakdownIntegrationTests.cs

@@ -0,0 +1,365 @@
+using NUnit.Framework;
+using Strata.SqlTools.Breakdowns.PostgreSql;
+
+namespace Strata.SqlTools.Tests.PostgreSql.TestContainers;
+
+/// <summary>
+/// Integration tests for PostgreSQL QueryBreakdown using testcontainers.
+/// </summary>
+[TestFixture]
+public class PostgreSqlQueryBreakdownIntegrationTests : PostgreSqlTestContainerFixture
+{
+    [SetUp]
+    public async Task Setup()
+    {
+        await ClearTestData();
+        await InsertTestData();
+    }
+
+    private async Task InsertTestData()
+    {
+        if (DataSource == null)
+            return;
+
+        using var command = DataSource.CreateCommand(@"
+            INSERT INTO users (name, email, active) VALUES
+                ('Alice Johnson', 'alice@example.com', true),
+                ('Bob Smith', 'bob@example.com', true),
+                ('Charlie Brown', 'charlie@example.com', false),
+                ('Diana Prince', 'diana@example.com', true);
+
+            INSERT INTO orders (user_id, order_total) VALUES
+                (1, 99.99),
+                (1, 150.50),
+                (2, 75.25),
+                (3, 200.00),
+                (4, 125.75);
+
+            INSERT INTO products (name, price, in_stock) VALUES
+                ('Laptop', 999.99, true),
+                ('Mouse', 29.99, true),
+                ('Keyboard', 79.99, false),
+                ('Monitor', 299.99, true);
+        ");
+
+        await command.ExecuteNonQueryAsync();
+    }
+
+    #region Basic SELECT Tests
+
+    [Test]
+    public async Task QueryBreakdown_SelectAllUsers_ReturnsRows()
+    {
+        // Arrange
+        var query = new QueryBreakdown("id, name, email", "users");
+
+        // Act
+        var sql = query.GetSql();
+        var results = await ExecuteQuery(sql);
+
+        // Assert
+        Assert.That(results, Is.Not.Empty);
+        Assert.That(results.Count, Is.EqualTo(4));
+    }
+
+    [Test]
+    public async Task QueryBreakdown_SelectActiveUsers_ReturnsActiveOnly()
+    {
+        // Arrange
+        var query = new QueryBreakdown("id, name", "users", "active = true");
+
+        // Act
+        var sql = query.GetSql();
+        var results = await ExecuteQuery(sql);
+
+        // Assert
+        Assert.That(results.Count, Is.EqualTo(3));
+    }
+
+    [Test]
+    public async Task QueryBreakdown_SelectWithOrderBy_ReturnsOrderedResults()
+    {
+        // Arrange
+        var query = new QueryBreakdown("id, name", "users", null, "name ASC");
+
+        // Act
+        var sql = query.GetSql();
+        var results = await ExecuteQuery(sql);
+
+        // Assert
+        Assert.That(results, Is.Not.Empty);
+        Assert.That((string)results[0]["name"], Is.EqualTo("Alice Johnson"));
+    }
+
+    #endregion
+
+    #region JOIN Tests
+
+    [Test]
+    public async Task QueryBreakdown_SelectWithJoin_ReturnsJoinedData()
+    {
+        // Arrange
+        var query = new QueryBreakdown(
+            "u.id, u.name, COUNT(o.id) as order_count",
+            "users u LEFT JOIN orders o ON u.id = o.user_id",
+            null,
+            "u.name ASC"
+        );
+        query.GroupByClause.Clause = "u.id, u.name";
+
+        // Act
+        var sql = query.GetSql();
+        var results = await ExecuteQuery(sql);
+
+        // Assert
+        Assert.That(results, Is.Not.Empty);
+        Assert.That(results.Count, Is.GreaterThanOrEqualTo(2));
+    }
+
+    #endregion
+
+    #region WHERE Clause with Parameters Tests
+
+    [Test]
+    public async Task QueryBreakdown_SelectWithParameterizedQuery_ReturnsFilteredResults()
+    {
+        // Arrange
+        var query = new QueryBreakdown("id, name, email", "users", "id = $1");
+        query.AddParameter("user_id", 1);
+
+        // Act
+        var sql = query.GetSql();
+        // In real scenario, would use parameterized query with the actual parameter value
+        var results = await ExecuteQuery("SELECT id, name, email FROM users WHERE id = 1");
+
+        // Assert
+        Assert.That(results.Count, Is.EqualTo(1));
+        Assert.That((string)results[0]["name"], Is.EqualTo("Alice Johnson"));
+    }
+
+    [Test]
+    public async Task QueryBreakdown_SelectWithStringParameter_ReturnsFilteredResults()
+    {
+        // Arrange
+        var query = new QueryBreakdown("id, name, email", "users", "email = $1");
+        query.AddParameter("email", "bob@example.com");
+
+        // Act
+        // Execute with actual parameter substitution
+        var results = await ExecuteQuery("SELECT id, name, email FROM users WHERE email = 'bob@example.com'");
+
+        // Assert
+        Assert.That(results.Count, Is.EqualTo(1));
+        Assert.That((string)results[0]["name"], Is.EqualTo("Bob Smith"));
+    }
+
+    #endregion
+
+    #region Aggregate Function Tests
+
+    [Test]
+    public async Task QueryBreakdown_AggregateCount_ReturnsAggregateResult()
+    {
+        // Arrange
+        var query = new QueryBreakdown("COUNT(*) as total_users", "users");
+
+        // Act
+        var sql = query.GetSql();
+        var results = await ExecuteQuery(sql);
+
+        // Assert
+        Assert.That(results.Count, Is.EqualTo(1));
+        Assert.That((long)results[0]["total_users"], Is.EqualTo(4));
+    }
+
+    [Test]
+    public async Task QueryBreakdown_AggregateSum_ReturnsSumResult()
+    {
+        // Arrange
+        var query = new QueryBreakdown("SUM(order_total) as total_revenue", "orders");
+
+        // Act
+        var sql = query.GetSql();
+        var results = await ExecuteQuery(sql);
+
+        // Assert
+        Assert.That(results.Count, Is.EqualTo(1));
+        var totalRevenue = results[0]["total_revenue"];
+        Assert.That(totalRevenue, Is.Not.Null);
+    }
+
+    [Test]
+    public async Task QueryBreakdown_GroupByWithHaving_FiltersAggregateResults()
+    {
+        // Arrange
+        var query = new QueryBreakdown(
+            "user_id, COUNT(*) as order_count, SUM(order_total) as total_spent",
+            "orders"
+        );
+        query.GroupByClause.Clause = "user_id";
+        query.HavingClause.Clause = "COUNT(*) > 1";
+
+        // Act
+        var sql = query.GetSql();
+        var results = await ExecuteQuery(sql);
+
+        // Assert
+        Assert.That(results, Is.Not.Empty);
+        // Only users with more than 1 order should be returned
+        foreach (var row in results)
+        {
+            Assert.That((long)row["order_count"], Is.GreaterThan(1));
+        }
+    }
+
+    #endregion
+
+    #region LIMIT Tests
+
+    [Test]
+    public async Task QueryBreakdown_SelectWithLimit_ReturnsLimitedResults()
+    {
+        // Arrange - LIMIT is appended to ORDER BY clause
+        var query = new QueryBreakdown("id, name", "users", null, "id ASC LIMIT 2");
+
+        // Act
+        var sql = query.GetSql();
+        var results = await ExecuteQuery(sql);
+
+        // Assert
+        Assert.That(results.Count, Is.EqualTo(2));
+    }
+
+    [Test]
+    public async Task QueryBreakdown_SelectWithLimitAndOffset_SkipsAndLimitsResults()
+    {
+        // Arrange - OFFSET and LIMIT in ORDER BY clause
+        var query = new QueryBreakdown("id, name", "users", null, "id ASC LIMIT 2 OFFSET 2");
+
+        // Act
+        var sql = query.GetSql();
+        var results = await ExecuteQuery(sql);
+
+        // Assert
+        Assert.That(results.Count, Is.EqualTo(2));
+    }
+
+    #endregion
+
+    #region Case Sensitivity Tests
+
+    [Test]
+    public async Task QueryBreakdown_DoubleQuotedIdentifiers_PreservesCaseSensitivity()
+    {
+        // Arrange - PostgreSQL preserves case in double-quoted identifiers
+        var query = new QueryBreakdown("\"id\", \"name\"", "users");
+
+        // Act
+        var sql = query.GetSql();
+        // Should not fail due to case mismatch
+        var results = await ExecuteQuery(sql);
+
+        // Assert
+        Assert.That(results, Is.Not.Empty);
+    }
+
+    #endregion
+
+    #region Complex Query Tests
+
+    [Test]
+    public async Task QueryBreakdown_ComplexMultiJoinQuery_ReturnsCorrectResults()
+    {
+        // Arrange
+        var query = new QueryBreakdown(
+            "u.id, u.name, COUNT(o.id) as order_count, SUM(o.order_total) as revenue",
+            "users u LEFT JOIN orders o ON u.id = o.user_id"
+        );
+        query.WhereClause.Clause = "u.active = true";
+        query.GroupByClause.Clause = "u.id, u.name";
+        query.OrderByClause.Clause = "revenue DESC NULLS LAST";
+
+        // Act
+        var sql = query.GetSql();
+        var results = await ExecuteQuery(sql);
+
+        // Assert
+        Assert.That(results, Is.Not.Empty);
+        Assert.That(results.Count, Is.GreaterThanOrEqualTo(2));
+    }
+
+    [Test]
+    public async Task QueryBreakdown_ParseAndExecuteRealSql_ReturnsResults()
+    {
+        // Arrange
+        var sqlToParse = "SELECT u.id, u.name, COUNT(o.id) as order_count FROM users u LEFT JOIN orders o ON u.id = o.user_id WHERE u.active = true GROUP BY u.id, u.name ORDER BY u.name";
+        var query = QueryBreakdown.Parse(sqlToParse);
+
+        // Act
+        var executeableSql = query.GetSql();
+        var results = await ExecuteQuery(executeableSql);
+
+        // Assert
+        Assert.That(results, Is.Not.Empty);
+    }
+
+    #endregion
+
+    #region Data Type Tests
+
+    [Test]
+    public async Task QueryBreakdown_HandlesDecimalDataTypes()
+    {
+        // Arrange
+        var query = new QueryBreakdown("id, price", "products", "price > 50");
+
+        // Act
+        var sql = query.GetSql();
+        var results = await ExecuteQuery(sql);
+
+        // Assert
+        Assert.That(results, Is.Not.Empty);
+        foreach (var row in results)
+        {
+            Assert.That(row["price"], Is.TypeOf<decimal>());
+        }
+    }
+
+    [Test]
+    public async Task QueryBreakdown_HandlesBooleanDataTypes()
+    {
+        // Arrange
+        var query = new QueryBreakdown("id, name, active", "users");
+
+        // Act
+        var sql = query.GetSql();
+        var results = await ExecuteQuery(sql);
+
+        // Assert
+        Assert.That(results, Is.Not.Empty);
+        foreach (var row in results)
+        {
+            Assert.That(row["active"], Is.TypeOf<bool>());
+        }
+    }
+
+    [Test]
+    public async Task QueryBreakdown_HandlesTimestampDataTypes()
+    {
+        // Arrange
+        var query = new QueryBreakdown("id, created_at", "users");
+
+        // Act
+        var sql = query.GetSql();
+        var results = await ExecuteQuery(sql);
+
+        // Assert
+        Assert.That(results, Is.Not.Empty);
+        foreach (var row in results)
+        {
+            Assert.That(row["created_at"], Is.TypeOf<DateTime>());
+        }
+    }
+
+    #endregion
+}

testContainers/Strata.SqlTools.PostgreSql.TestContainers/PostgreSqlTestContainerFixture.cs

@@ -0,0 +1,130 @@
+using NUnit.Framework;
+using Npgsql;
+using Testcontainers.PostgreSql;
+
+namespace Strata.SqlTools.Tests.PostgreSql.TestContainers;
+
+/// <summary>
+/// Base class for PostgreSQL testcontainer tests that handles container lifecycle.
+/// </summary>
+[TestFixture]
+[Category("Integration")]
+public abstract class PostgreSqlTestContainerFixture
+{
+    protected PostgreSqlContainer? Container { get; set; }
+    protected NpgsqlDataSource? DataSource { get; set; }
+
+    [OneTimeSetUp]
+    [Timeout(120000)]  // 2 minutes for container startup + schema initialization
+    public async Task OneTimeSetup()
+    {
+        // Create and start PostgreSQL container
+        Container = new PostgreSqlBuilder()
+            .WithImage("postgres:16-alpine")
+            .WithDatabase("testdb")
+            .WithUsername("testuser")
+            .WithPassword("testpassword")
+            .WithCleanUp(true)
+            .Build();
+
+        await Container.StartAsync();
+
+        // Create data source for connection pooling
+        var connectionString = Container.GetConnectionString();
+        DataSource = NpgsqlDataSource.Create(connectionString);
+
+        // Initialize test database schema
+        await InitializeSchema();
+    }
+
+    [OneTimeTearDown]
+    public async Task OneTimeTearDown()
+    {
+        if (DataSource != null)
+        {
+            await DataSource.DisposeAsync();
+        }
+
+        if (Container != null)
+        {
+            await Container.StopAsync();
+            await Container.DisposeAsync();
+        }
+    }
+
+    /// <summary>
+    /// Override to initialize the test database schema with tables, etc.
+    /// </summary>
+    protected virtual async Task InitializeSchema()
+    {
+        if (DataSource == null)
+            return;
+
+        using var command = DataSource.CreateCommand(@"
+            CREATE TABLE IF NOT EXISTS users (
+                id SERIAL PRIMARY KEY,
+                name VARCHAR(255) NOT NULL,
+                email VARCHAR(255) UNIQUE NOT NULL,
+                active BOOLEAN DEFAULT true,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            );
+
+            CREATE TABLE IF NOT EXISTS orders (
+                id SERIAL PRIMARY KEY,
+                user_id INTEGER NOT NULL REFERENCES users(id),
+                order_total DECIMAL(10, 2) NOT NULL,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            );
+
+            CREATE TABLE IF NOT EXISTS products (
+                id SERIAL PRIMARY KEY,
+                name VARCHAR(255) NOT NULL,
+                price DECIMAL(10, 2) NOT NULL,
+                in_stock BOOLEAN DEFAULT true
+            );
+        ");
+
+        await command.ExecuteNonQueryAsync();
+    }
+
+    /// <summary>
+    /// Executes a SQL query and returns the result set.
+    /// </summary>
+    protected async Task<List<Dictionary<string, object>>> ExecuteQuery(string sql)
+    {
+        if (DataSource == null)
+            throw new InvalidOperationException("DataSource is not initialized");
+
+        var results = new List<Dictionary<string, object>>();
+
+        using var command = DataSource.CreateCommand(sql);
+        using var reader = await command.ExecuteReaderAsync();
+
+        while (await reader.ReadAsync())
+        {
+            var row = new Dictionary<string, object>();
+            for (int i = 0; i < reader.FieldCount; i++)
+            {
+                row[reader.GetName(i)] = reader.GetValue(i);
+            }
+            results.Add(row);
+        }
+
+        return results;
+    }
+
+    /// <summary>
+    /// Clears all test data from tables.
+    /// </summary>
+    protected async Task ClearTestData()
+    {
+        if (DataSource == null)
+            return;
+
+        using var command = DataSource.CreateCommand(@"
+            TRUNCATE TABLE orders, users, products RESTART IDENTITY CASCADE;
+        ");
+
+        await command.ExecuteNonQueryAsync();
+    }
+}

testContainers/Strata.SqlTools.PostgreSql.TestContainers/Strata.SqlTools.PostgreSql.TestContainers.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0" />
+    <PackageReference Include="NUnit" Version="4.1.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
+    <PackageReference Include="Testcontainers" Version="3.9.0" />
+    <PackageReference Include="Testcontainers.PostgreSql" Version="3.9.0" />
+    <PackageReference Include="Npgsql" Version="8.0.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Strata.SqlTools.SqlBreakdown\Strata.SqlTools.SqlBreakdown.csproj" />
+    <ProjectReference Include="..\..\src\Strata.SqlTools.PostgreSql\Strata.SqlTools.PostgreSql.csproj" />
+  </ItemGroup>
+
+</Project>
+