sql-utilities/tests/Strata.SqlTools.SqlServer.Tests/SqlServer/DeleteBreakdownTests.cs

using Strata.SqlTools.Breakdowns.SqlServer;

namespace Strata.SqlTools.SqlBreakdown.Tests.SqlServer;

[TestFixture]
public class DeleteBreakdownTests
{
    #region Constructor Tests

    [Test]
    public void Constructor_Default_InitializesEmptyClauses()
    {
        // Arrange & Act
        var breakdown = new DeleteBreakdown();

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.FromClause.Clause, Is.EqualTo(string.Empty));
            Assert.That(breakdown.WhereClause.Clause, Is.EqualTo(string.Empty));
            Assert.That(breakdown.DeleteClause.Clause, Is.EqualTo(string.Empty));
            Assert.That(breakdown.IsUsingWhereClause, Is.False);
        });
    }

    [Test]
    public void Constructor_WithClauses_SetsProperties()
    {
        // Arrange & Act
        var breakdown = new DeleteBreakdown("Users", "Id = @Id");

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.FromClause.Clause, Is.EqualTo("Users"));
            Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("Id = @Id"));
            Assert.That(breakdown.IsUsingWhereClause, Is.True);
        });
    }

    #endregion

    #region GetSql Tests

    [Test]
    public void GetSql_WithWhere_RendersDeleteFromWhere()
    {
        // Arrange
        var breakdown = new DeleteBreakdown("Users", "Id = @Id");

        // Act
        var sql = breakdown.GetSql();

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(sql, Does.Contain("DELETE"));
            Assert.That(sql, Does.Contain("FROM"));
            Assert.That(sql, Does.Contain("Users"));
            Assert.That(sql, Does.Contain("WHERE"));
            Assert.That(sql, Does.Contain("Id = @Id"));
        });
    }

    [Test]
    public void GetSql_WithoutWhere_OmitsWhereKeyword()
    {
        // Arrange
        var breakdown = new DeleteBreakdown("Users", string.Empty);

        // Act
        var sql = breakdown.GetSql();

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(sql, Does.Contain("DELETE"));
            Assert.That(sql, Does.Not.Contain("WHERE"));
        });
    }

    [Test]
    public void GetSql_WithDeleteClause_RendersAlias()
    {
        // Arrange
        var breakdown = new DeleteBreakdown("Users u", "u.Id = 1")
        {
            DeleteClause = { Clause = "u" }
        };

        // Act
        var sql = breakdown.GetSql();

        // Assert
        Assert.That(sql, Does.Contain("DELETE"));
        Assert.That(sql, Does.Contain("u"));
    }

    #endregion

    #region Parse Tests

    [Test]
    public void Parse_SimpleDeleteFrom_PopulatesClauses()
    {
        // Arrange
        var input = "DELETE FROM Users WHERE Id = 1";

        // Act
        var breakdown = DeleteBreakdown.Parse(input);

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.FromClause.Clause, Is.EqualTo("Users"));
            Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("Id = 1"));
        });
    }

    [Test]
    public void Parse_DeleteWithAlias_PopulatesDeleteAndFromClauses()
    {
        // Arrange - DELETE u FROM Users u WHERE ... uses the alias pattern
        var input = "DELETE u FROM Users u WHERE u.Id = 1";

        // Act
        var breakdown = DeleteBreakdown.Parse(input);

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.DeleteClause.Clause, Is.EqualTo("u"));
            Assert.That(breakdown.FromClause.Clause, Is.EqualTo("Users u"));
            Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("u.Id = 1"));
        });
    }

    [Test]
    public void Parse_DeleteWithoutWhere_LeavesWhereEmpty()
    {
        // Arrange
        var input = "DELETE FROM Users";

        // Act
        var breakdown = DeleteBreakdown.Parse(input);

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.FromClause.Clause, Is.EqualTo("Users"));
            Assert.That(breakdown.IsUsingWhereClause, Is.False);
        });
    }

    [Test]
    public void Parse_NullOrWhitespace_ThrowsArgumentNullException()
    {
        // Act & Assert
        Assert.Throws<ArgumentNullException>(() => DeleteBreakdown.Parse(null!));
    }

    [Test]
    public void Parse_NotADeleteStatement_ThrowsFormatException()
    {
        // Act & Assert
        Assert.Throws<FormatException>(() => DeleteBreakdown.Parse("SELECT * FROM Users"));
    }

    [Test]
    public void TryParse_WrongPrefix_ReturnsFalseWithMessage()
    {
        // Act
        var success = DeleteBreakdown.TryParse("UPDATE Users SET Id = 1", out _, out var error);

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(success, Is.False);
            Assert.That(error, Does.Contain("DELETE"));
        });
    }

    [Test]
    public void TryParse_ValidDelete_ReturnsTrue()
    {
        // Act
        var success = DeleteBreakdown.TryParse("DELETE FROM Users WHERE Id = 1", out var breakdown);

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(success, Is.True);
            Assert.That(breakdown.FromClause.Clause, Is.EqualTo("Users"));
        });
    }

    #endregion
}