sql-utilities/tests/Strata.SqlTools.Markdown.Tests/PostgreSql/QueryBreakdownCollectionGeneratorTests.cs

using Strata.SqlTools.Breakdowns.PostgreSql;
using Strata.SqlTools.Markdown.PostgreSql;

namespace Strata.SqlTools.Markdown.Tests.PostgreSql;

[TestFixture]
public class QueryBreakdownCollectionGeneratorTests
{
    private QueryBreakdownCollection _collection = null!;

    [SetUp]
    public void Setup()
    {
        _collection = new QueryBreakdownCollection();
    }

    [Test]
    public void GenerateCollectionReport_WithTitle_IncludesTitle()
    {
        // Arrange
        _collection.Add(new QueryBreakdown("id, name", "users"));
        var title = "PostgreSQL Query Report";

        // Act
        var report = QueryBreakdownCollectionGenerator.GenerateCollectionReport(_collection, title);

        // Assert
        Assert.That(report, Does.Contain(title));
        Assert.That(report, Does.Contain("# PostgreSQL Query Report"));
    }

    [Test]
    public void GenerateCollectionReport_WithMultipleQueries_GeneratesCompleteReport()
    {
        // Arrange
        _collection.Add(new QueryBreakdown("id, name, email", "users"));
        _collection.Add(new QueryBreakdown("order_id, amount", "orders"));

        // Act
        var report = QueryBreakdownCollectionGenerator.GenerateCollectionReport(_collection);

        // Assert
        Assert.That(report, Does.Contain("Collection Summary"));
        Assert.That(report, Does.Contain("Parameter Analysis"));
        Assert.That(report, Does.Contain("Query Composition Report"));
    }

    [Test]
    public void GenerateCollectionSummary_WithQueries_IncludesSummaryMetrics()
    {
        // Arrange
        _collection.Add(new QueryBreakdown("id, name, email", "users"));
        _collection.Add(new QueryBreakdown("order_id, amount", "orders"));

        // Act
        var summary = QueryBreakdownCollectionGenerator.GenerateCollectionSummary(_collection);

        // Assert
        Assert.That(summary, Does.Contain("Collection Summary"));
        Assert.That(summary, Does.Contain("Total Queries"));
        Assert.That(summary, Does.Contain("2"));
    }

    [Test]
    public void GenerateParameterAnalysis_NoParameters_IndicatesNoParameters()
    {
        // Arrange
        _collection.Add(new QueryBreakdown("id, name", "users"));

        // Act
        var analysis = QueryBreakdownCollectionGenerator.GenerateParameterAnalysis(_collection);

        // Assert
        Assert.That(analysis, Does.Contain("Parameters"));
        Assert.That(analysis, Does.Contain("No parameters"));
    }

    [Test]
    public void GenerateParameterAnalysis_WithPositionalParameters_ShowsPostgreSqlSyntax()
    {
        // Arrange - PostgreSQL positional parameters $1, $2
        var query = new QueryBreakdown("id, name", "users", "id = $1");
        query.Parameters["1"] = 123;
        _collection.Add(query);

        // Act
        var analysis = QueryBreakdownCollectionGenerator.GenerateParameterAnalysis(_collection);

        // Assert
        Assert.That(analysis, Does.Contain("Parameter Analysis"));
        Assert.That(analysis, Does.Contain("$1"));
        Assert.That(analysis, Does.Contain("Parameter Dependency Diagram"));
    }

    [Test]
    public void GenerateParameterAnalysis_WithNamedParameters_ShowsColonSyntax()
    {
        // Arrange - PostgreSQL named parameters with :
        var query = new QueryBreakdown("id, name", "users", "id = :userId");
        query.Parameters["userId"] = 123;
        _collection.Add(query);

        // Act
        var analysis = QueryBreakdownCollectionGenerator.GenerateParameterAnalysis(_collection);

        // Assert
        Assert.That(analysis, Does.Contain("Parameter Analysis"));
        Assert.That(analysis, Does.Contain(":userId"));
        Assert.That(analysis, Does.Contain("Parameter Dependency Diagram"));
    }

    [Test]
    public void GenerateParameterDependencyDiagram_WithParameters_GeneratesMermaidDiagram()
    {
        // Arrange
        var query1 = new QueryBreakdown("id, name", "users", "id = $1");
        var query2 = new QueryBreakdown("order_id", "orders", "user_id = $1");
        query1.Parameters["1"] = 123;
        query2.Parameters["1"] = 123;
        _collection.Add(query1);
        _collection.Add(query2);

        // Act
        var diagram = QueryBreakdownCollectionGenerator.GenerateParameterDependencyDiagram(_collection);

        // Assert
        Assert.That(diagram, Does.Contain("```mermaid"));
        Assert.That(diagram, Does.Contain("graph TD"));
        Assert.That(diagram, Does.Contain("$1"));
        Assert.That(diagram, Does.Contain("Query #0"));
        Assert.That(diagram, Does.Contain("Query #1"));
        Assert.That(diagram, Does.Contain("```"));
    }

    [Test]
    public void GenerateQueryCompositionReport_WithQueries_IncludesAllQueryDetails()
    {
        // Arrange
        var query = new QueryBreakdown("id, name", "users", "id > 10");
        query.GroupByClause.Clause = "region";
        query.OrderByClause.Clause = "name ASC";
        _collection.Add(query);

        // Act
        var report = QueryBreakdownCollectionGenerator.GenerateQueryCompositionReport(_collection);

        // Assert
        Assert.That(report, Does.Contain("Query Composition Report"));
        Assert.That(report, Does.Contain("Query #0"));
        Assert.That(report, Does.Contain("SELECT Clause"));
        Assert.That(report, Does.Contain("✓ Yes"));
        Assert.That(report, Does.Contain("WHERE Clause"));
    }

    [Test]
    public void GenerateQueryCompositionReport_WithCTEs_IncludesCTEList()
    {
        // Arrange
        var query = new QueryBreakdown("id, name", "users");
        var cteQuery = new QueryBreakdown("id, name", "archive_users");
        query.AddWithClause("active_users", cteQuery);
        _collection.Add(query);

        // Act
        var report = QueryBreakdownCollectionGenerator.GenerateQueryCompositionReport(_collection);

        // Assert
        Assert.That(report, Does.Contain("CTEs Defined"));
        Assert.That(report, Does.Contain("active_users"));
    }

    [Test]
    public void GenerateQueryCompositionReport_WithParameters_IncludesParameterValues()
    {
        // Arrange - PostgreSQL positional parameters
        var query = new QueryBreakdown("id, name", "users", "id = $1 AND status = $2");
        query.Parameters["1"] = 123;
        query.Parameters["2"] = "Active";
        _collection.Add(query);

        // Act
        var report = QueryBreakdownCollectionGenerator.GenerateQueryCompositionReport(_collection);

        // Assert
        Assert.That(report, Does.Contain("Parameters Used"));
        Assert.That(report, Does.Contain("$1"));
        Assert.That(report, Does.Contain("$2"));
        Assert.That(report, Does.Contain("123"));
        Assert.That(report, Does.Contain("Active"));
    }

    [Test]
    public void GenerateBatchFlowDiagram_WithQueries_GeneratesFlowDiagram()
    {
        // Arrange
        _collection.Add(new QueryBreakdown("id, name", "users"));
        _collection.Add(new QueryBreakdown("order_id", "orders"));

        // Act
        var diagram = QueryBreakdownCollectionGenerator.GenerateBatchFlowDiagram(_collection);

        // Assert
        Assert.That(diagram, Does.Contain("```mermaid"));
        Assert.That(diagram, Does.Contain("flowchart TD"));
        Assert.That(diagram, Does.Contain("Batch Start"));
        Assert.That(diagram, Does.Contain("Query 0"));
        Assert.That(diagram, Does.Contain("Query 1"));
        Assert.That(diagram, Does.Contain("Batch Complete"));
        Assert.That(diagram, Does.Contain("```"));
    }

    [Test]
    public void GenerateBatchFlowDiagram_WithTransaction_IncludesBeginCommit()
    {
        // Arrange
        _collection.Add(new QueryBreakdown("id, name", "users"));

        // Act
        var diagram = QueryBreakdownCollectionGenerator.GenerateBatchFlowDiagram(_collection, includeTransaction: true);

        // Assert
        Assert.That(diagram, Does.Contain("BEGIN"));
        Assert.That(diagram, Does.Contain("COMMIT"));
    }

    [Test]
    public void GenerateBatchFlowDiagram_WithQueries_ValidatesProperConnections()
    {
        // Arrange
        _collection.Add(new QueryBreakdown("id, name", "users"));
        _collection.Add(new QueryBreakdown("order_id", "orders"));
        _collection.Add(new QueryBreakdown("product_id", "products"));

        // Act
        var diagram = QueryBreakdownCollectionGenerator.GenerateBatchFlowDiagram(_collection);

        // Assert
        // Verify proper connections between nodes
        Assert.That(diagram, Does.Contain("Start([Batch Start]) --> node0"));  // Start connects to first node
        Assert.That(diagram, Does.Contain("node0[\"Query 0\"] --> node1"));     // Query 0 to Query 1
        Assert.That(diagram, Does.Contain("node1[\"Query 1\"] --> node2"));     // Query 1 to Query 2
        Assert.That(diagram, Does.Contain("node2[\"Query 2\"] --> End"));       // Last query connects to End
        // Verify no dangling nodes
        Assert.That(diagram, Does.Not.Contain("node3"));                        // No extra unconnected node
    }

    [Test]
    public void GenerateBatchFlowDiagram_WithTransaction_ValidatesProperConnections()
    {
        // Arrange
        _collection.Add(new QueryBreakdown("id, name", "users"));
        _collection.Add(new QueryBreakdown("order_id", "orders"));

        // Act
        var diagram = QueryBreakdownCollectionGenerator.GenerateBatchFlowDiagram(_collection, includeTransaction: true);

        // Assert
        // Verify proper transaction flow
        Assert.That(diagram, Does.Contain("Start([Batch Start]) --> node0"));  // Start connects to BEGIN
        Assert.That(diagram, Does.Contain("node0[\"BEGIN\"]"));                // BEGIN node
        Assert.That(diagram, Does.Contain("node0 --> node1"));                 // BEGIN to first query
        Assert.That(diagram, Does.Contain("node1[\"Query 0\"] --> node2"));    // Query 0 to Query 1
        Assert.That(diagram, Does.Contain("node2[\"Query 1\"] --> node3"));    // Last query to COMMIT
        Assert.That(diagram, Does.Contain("node3[\"COMMIT\"]"));               // COMMIT node
        Assert.That(diagram, Does.Contain("node3 --> End"));                   // COMMIT to End
    }

    [Test]
    public void GenerateCollectionReport_EmptyCollection_GeneratesValidMarkdown()
    {
        // Act
        var report = QueryBreakdownCollectionGenerator.GenerateCollectionReport(_collection);

        // Assert
        Assert.That(report, Does.Contain("Collection Summary"));
        Assert.That(report, Does.Contain("Parameter Analysis"));
        Assert.That(report, Does.Contain("Total Queries"));
        Assert.That(report, Does.Contain("0"));
    }

    [Test]
    public void GenerateCollectionReport_WithMultipleQueries_ContainsAllSections()
    {
        // Arrange
        _collection.Add(new QueryBreakdown("id, name", "users"));

        // Act
        var report = QueryBreakdownCollectionGenerator.GenerateCollectionReport(_collection);

        // Assert
        Assert.That(report, Does.Contain("## Collection Summary"));
        Assert.That(report, Does.Contain("## Parameter Analysis"));
        Assert.That(report, Does.Contain("## Query Composition Report"));
    }

    [Test]
    public void GenerateBatchFlowDiagram_EmptyCollection_GeneratesValidDiagram()
    {
        // Act
        var diagram = QueryBreakdownCollectionGenerator.GenerateBatchFlowDiagram(_collection);

        // Assert
        Assert.That(diagram, Does.Contain("```mermaid"));
        Assert.That(diagram, Does.Contain("flowchart TD"));
        Assert.That(diagram, Does.Contain("Batch Start"));
        Assert.That(diagram, Does.Contain("Batch Complete"));
    }

    [Test]
    public void GenerateBatchFlowDiagram_EmptyCollectionWithTransaction_IncludesTransactionNodes()
    {
        // Act
        var diagram = QueryBreakdownCollectionGenerator.GenerateBatchFlowDiagram(_collection, includeTransaction: true);

        // Assert
        Assert.That(diagram, Does.Contain("BEGIN"));
        Assert.That(diagram, Does.Contain("COMMIT"));
    }
}