sql-utilities/tests/Strata.SqlTools.EFCore.Tests/QueryBreakdownMapperTests.cs

using NUnit.Framework;
using Strata.SqlTools.Breakdowns.SqlServer;
using Strata.SqlTools.EFCore.Models;
using Strata.SqlTools.EFCore.Services;

namespace Strata.SqlTools.EFCore.Tests;

[TestFixture]
public class QueryBreakdownMapperTests
{
    private QueryBreakdownMapper _mapper = null!;

    [SetUp]
    public void Setup()
    {
        _mapper = new QueryBreakdownMapper();
    }

    [Test]
    public void MapToEntity_WithSimpleQuery_ReturnsValidEntity()
    {
        // Arrange
        var queryBreakdown = new QueryBreakdown("ID, Name", "Users");

        // Act
        var entity = _mapper.MapToEntity(queryBreakdown);

        // Assert
        Assert.That(entity, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(entity.SelectClause, Is.EqualTo("ID, Name"));
            Assert.That(entity.FromClause, Is.EqualTo("Users"));
            Assert.That(entity.CreatedAt, Is.LessThanOrEqualTo(DateTime.UtcNow));
        });
    }

    [Test]
    public void MapToEntity_WithCompleteQuery_ReturnsEntityWithAllClauses()
    {
        // Arrange
        var queryBreakdown = new QueryBreakdown(
            "ID, Name",
            "Users",
            "Active = 1",
            "Name ASC"
        );

        // Act
        var entity = _mapper.MapToEntity(queryBreakdown);

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(entity.SelectClause, Is.EqualTo("ID, Name"));
            Assert.That(entity.FromClause, Is.EqualTo("Users"));
            Assert.That(entity.WhereClause, Is.EqualTo("Active = 1"));
            Assert.That(entity.OrderByClause, Is.EqualTo("Name ASC"));
        });
    }

    [Test]
    public void MapToDomainModel_WithEntity_ReturnsValidQueryBreakdown()
    {
        // Arrange
        var entity = new QueryBreakdownEntity
        {
            Id = 1,
            SelectClause = "ID, Name",
            FromClause = "Users",
            WhereClause = "Active = 1",
            CreatedAt = DateTime.UtcNow,
            UpdatedAt = DateTime.UtcNow
        };

        // Act
        var queryBreakdown = _mapper.MapToDomainModel(entity);

        // Assert
        Assert.That(queryBreakdown, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(queryBreakdown.SelectClause?.Clause, Is.EqualTo("ID, Name"));
            Assert.That(queryBreakdown.FromClause?.Clause, Is.EqualTo("Users"));
            Assert.That(queryBreakdown.WhereClause?.Clause, Is.EqualTo("Active = 1"));
        });
    }

    [Test]
    public void MapToEntity_WithParameters_SerializesParametersAsJson()
    {
        // Arrange
        var queryBreakdown = new QueryBreakdown("ID, Name", "Users");
        queryBreakdown.AddParameter("UserId", 123);
        queryBreakdown.AddParameter("Status", "Active");

        // Act
        var entity = _mapper.MapToEntity(queryBreakdown);

        // Assert
        Assert.That(entity.ParametersJson, Is.Not.Null);
        Assert.That(entity.ParametersJson, Does.Contain("UserId"));
        Assert.That(entity.ParametersJson, Does.Contain("Status"));
    }

    [Test]
    public void RoundTrip_Conversion_PreservesQueryData()
    {
        // Arrange
        var originalQuery = new QueryBreakdown(
            "ID, Name, Email",
            "Users",
            "Active = 1 AND CreatedDate > @CreatedDate",
            "Name ASC"
        );
        originalQuery.AddParameter("CreatedDate", "2024-01-01");

        // Act
        var entity = _mapper.MapToEntity(originalQuery);
        var restoredQuery = _mapper.MapToDomainModel(entity);

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(restoredQuery.SelectClause?.Clause, Is.EqualTo(originalQuery.SelectClause?.Clause));
            Assert.That(restoredQuery.FromClause?.Clause, Is.EqualTo(originalQuery.FromClause?.Clause));
            Assert.That(restoredQuery.WhereClause?.Clause, Is.EqualTo(originalQuery.WhereClause?.Clause));
            Assert.That(restoredQuery.OrderByClause?.Clause, Is.EqualTo(originalQuery.OrderByClause?.Clause));
        });
    }

    [Test]
    public void MapToEntityWithRelations_WithQueryBreakdown_ReturnsEntityAndRelations()
    {
        // Arrange
        var queryBreakdown = new QueryBreakdown("ID, Name", "Users");
        queryBreakdown.AddParameter("UserId", 1);

        // Act
        var (entity, parameters, withClauses) = _mapper.MapToEntityWithRelations(queryBreakdown);

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(entity, Is.Not.Null);
            Assert.That(parameters, Is.Not.Empty);
        });
        Assert.Multiple(() =>
        {
            Assert.That(parameters.First().ParameterName, Is.EqualTo("UserId"));
            Assert.That(withClauses, Is.Empty);
        });
    }
}