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

using Strata.SqlTools.Breakdowns.SqlServer;

namespace Strata.SqlTools.SqlBreakdown.Tests.SqlServer;

[TestFixture]
public class ProcedureBreakdownTests
{
    #region Constructor Tests

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

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.ProcedureName.Clause, Is.EqualTo(string.Empty));
            Assert.That(breakdown.Parameters, Is.Empty);
            Assert.That(breakdown.IsUsingParameters, Is.False);
        });
    }

    [Test]
    public void Constructor_WithName_SetsProcedureName()
    {
        // Arrange & Act
        var breakdown = new ProcedureBreakdown("dbo.GetUsers");

        // Assert
        Assert.That(breakdown.ProcedureName.Clause, Is.EqualTo("dbo.GetUsers"));
    }

    [Test]
    public void Constructor_WithParameters_SetsParameters()
    {
        // Arrange
        var parameters = new Dictionary<string, string> { ["@Id"] = "1" };

        // Act
        var breakdown = new ProcedureBreakdown("dbo.GetUser", parameters);

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.IsUsingParameters, Is.True);
            Assert.That(breakdown.Parameters["@Id"], Is.EqualTo("1"));
        });
    }

    #endregion

    #region AddParameter Tests

    [Test]
    public void AddParameter_WithoutAtPrefix_AddsAtPrefix()
    {
        // Arrange
        var breakdown = new ProcedureBreakdown("dbo.GetUser");

        // Act
        breakdown.AddParameter("Id", "1");

        // Assert
        Assert.That(breakdown.Parameters.ContainsKey("@Id"), Is.True);
    }

    [Test]
    public void AddParameter_WithAtPrefix_KeepsSinglePrefix()
    {
        // Arrange
        var breakdown = new ProcedureBreakdown("dbo.GetUser");

        // Act
        breakdown.AddParameter("@Id", "1");

        // Assert
        Assert.That(breakdown.Parameters.ContainsKey("@Id"), Is.True);
    }

    [Test]
    public void AddParameter_NullName_ThrowsArgumentNullException()
    {
        // Arrange
        var breakdown = new ProcedureBreakdown("dbo.GetUser");

        // Act & Assert
        Assert.Throws<ArgumentNullException>(() => breakdown.AddParameter("   ", "1"));
    }

    #endregion

    #region GetSql Tests

    [Test]
    public void GetSql_WithoutParameters_RendersExecName()
    {
        // Arrange
        var breakdown = new ProcedureBreakdown("dbo.GetUsers");

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

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(sql, Does.Contain("EXEC"));
            Assert.That(sql, Does.Contain("dbo.GetUsers"));
        });
    }

    [Test]
    public void GetSql_WithParameters_RendersNamedAssignments()
    {
        // Arrange
        var breakdown = new ProcedureBreakdown("dbo.GetUser");
        breakdown.AddParameter("@Id", "1");

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

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(sql, Does.Contain("EXEC"));
            Assert.That(sql, Does.Contain("@Id = 1"));
        });
    }

    #endregion

    #region Parse Tests

    [Test]
    public void Parse_ExecWithoutParameters_PopulatesName()
    {
        // Arrange
        var input = "EXEC dbo.GetUsers";

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

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.ProcedureName.Clause, Is.EqualTo("dbo.GetUsers"));
            Assert.That(breakdown.IsUsingParameters, Is.False);
        });
    }

    [Test]
    public void Parse_ExecWithParameters_PopulatesParameters()
    {
        // Arrange
        var input = "EXEC dbo.GetUser @Id = 1, @Active = 1";

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

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.ProcedureName.Clause, Is.EqualTo("dbo.GetUser"));
            Assert.That(breakdown.Parameters["@Id"], Is.EqualTo("1"));
            Assert.That(breakdown.Parameters["@Active"], Is.EqualTo("1"));
        });
    }

    [Test]
    public void Parse_ExecuteKeyword_IsAccepted()
    {
        // Act
        var breakdown = ProcedureBreakdown.Parse("EXECUTE dbo.GetUsers");

        // Assert
        Assert.That(breakdown.ProcedureName.Clause, Is.EqualTo("dbo.GetUsers"));
    }

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

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

    [Test]
    public void TryParse_WrongPrefix_ReturnsFalseWithMessage()
    {
        // Act
        var success = ProcedureBreakdown.TryParse("SELECT 1", out _, out var error);

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

    [Test]
    public void TryParse_ValidExec_ReturnsTrue()
    {
        // Act
        var success = ProcedureBreakdown.TryParse("EXEC dbo.GetUsers", out var breakdown);

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

    #endregion
}