sql-utilities/tests/Strata.SqlTools.Markdown.Tests/Expressions/SimpleExpressionGeneratorTests.cs

using Strata.SqlTools.SqlBreakdown.Expressions;
using Strata.SqlTools.SqlBreakdown.Expressions.Conditional.Logical;
using Strata.SqlTools.SqlBreakdown.Expressions.Literals;
using Strata.SqlTools.Markdown.Expressions;

namespace Strata.SqlTools.Markdown.Tests.Expressions;

[TestFixture]
public class SimpleExpressionGeneratorTests
{
    private SimpleExpressionGenerator _generator = null!;

    [SetUp]
    public void Setup()
    {
        _generator = new SimpleExpressionGenerator();
    }

    [Test]
    public void GenerateMarkdown_WithSimpleExpression_GeneratesSimpleDoc()
    {
        // Arrange
        var expression = new NumberLiteralExpression(42);

        // Act
        var result = _generator.GenerateMarkdown(expression);

        // Assert
        Assert.That(result, Does.Contain("## Expression"));
        Assert.That(result, Does.Contain("## Type Information"));
        Assert.That(result, Does.Contain("## Description"));
        Assert.That(result, Does.Contain("```sql"));
    }

    [Test]
    public void GenerateMarkdown_WithTitle_IncludesTitle()
    {
        // Arrange
        var expression = new StringLiteralExpression("test");

        // Act
        var result = _generator.GenerateMarkdown(expression, "Simple Expression");

        // Assert
        Assert.That(result, Does.StartWith("# Simple Expression"));
    }

    [Test]
    public void GenerateMarkdown_IncludesDescription()
    {
        // Arrange
        Expression left = new NumberLiteralExpression(100);
        Expression right = new NumberLiteralExpression(50);
        var expression = left == right;

        // Act
        var result = _generator.GenerateMarkdown(expression);

        // Assert
        Assert.That(result, Does.Contain("EqualToExpression"));
        Assert.That(result, Does.Contain("expression"));
    }

    [Test]
    public void GenerateComparisonTable_WithMultipleExpressions_GeneratesTable()
    {
        // Arrange
        var expressions = new Dictionary<string, Expression>
        {
            ["Price Filter"] = new NumberLiteralExpression(100) > new NumberLiteralExpression(50),
            ["Status Filter"] = new StringLiteralExpression("Active") == new StringLiteralExpression("Active"),
            ["Quantity Check"] = new NumberLiteralExpression(10) <= new NumberLiteralExpression(100)
        };

        // Act
        var result = _generator.GenerateComparisonTable(expressions);

        // Assert
        Assert.That(result, Does.Contain("| Name | Expression | Type |"));
        Assert.That(result, Does.Contain("|------|------------|------|"));
        Assert.That(result, Does.Contain("Price Filter"));
        Assert.That(result, Does.Contain("Status Filter"));
        Assert.That(result, Does.Contain("Quantity Check"));
    }

    [Test]
    public void GenerateComparisonTable_WithTitle_IncludesTitle()
    {
        // Arrange
        var expressions = new Dictionary<string, Expression>
        {
            ["Test"] = new NumberLiteralExpression(1)
        };

        // Act
        var result = _generator.GenerateComparisonTable(expressions, "Comparison Table");

        // Assert
        Assert.That(result, Does.StartWith("# Comparison Table"));
    }

    [Test]
    public void GenerateBulletList_WithExpressions_GeneratesList()
    {
        // Arrange
        var expressions = new List<Expression>
        {
            new NumberLiteralExpression(100),
            new StringLiteralExpression("Active"),
            new NumberLiteralExpression(5) + new NumberLiteralExpression(10)
        };

        // Act
        var result = _generator.GenerateBulletList(expressions);

        // Assert
        Assert.That(result, Does.Contain("- `100`"));
        Assert.That(result, Does.Contain("- `'Active'`"));
        Assert.That(result, Does.Contain("- `"));
        Assert.That(result, Does.Contain("*NumberLiteralExpression*"));
    }

    [Test]
    public void GenerateBulletList_WithTitle_IncludesTitle()
    {
        // Arrange
        var expressions = new List<Expression>
        {
            new NumberLiteralExpression(1)
        };

        // Act
        var result = _generator.GenerateBulletList(expressions, "Expression List");

        // Assert
        Assert.That(result, Does.StartWith("## Expression List"));
    }

    [Test]
    public void GenerateComparisonTable_WithOrExpression_GeneratesTable()
    {
        // Arrange
        var expr1 = new NumberLiteralExpression(1) > new NumberLiteralExpression(0);
        var expr2 = new NumberLiteralExpression(2) > new NumberLiteralExpression(0);
        var expressions = new Dictionary<string, Expression>
        {
            ["Test"] = new OrExpression(expr1, expr2)
        };

        // Act
        var result = _generator.GenerateComparisonTable(expressions);

        // Assert
        Assert.That(result, Does.Contain("Test"));
        Assert.That(result, Does.Contain("OrExpression"));
        Assert.That(result, Does.Contain("OR"));
    }
}