chore: initial git load of code space

2026-05-12 08:52:33 -05:00
parent 9abada692f
commit 5e467bcc9c
384 changed files with 65960 additions and 2 deletions
@@ -0,0 +1,136 @@
+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.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
+        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.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
+        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
+        Assert.That(entity, Is.Not.Null);
+        Assert.That(parameters, Is.Not.Empty);
+        Assert.That(parameters.First().ParameterName, Is.EqualTo("UserId"));
+        Assert.That(withClauses, Is.Empty);
+    }
+}
@@ -0,0 +1,164 @@
+using Microsoft.EntityFrameworkCore;
+using NUnit.Framework;
+using Strata.SqlTools.Breakdowns.SqlServer;
+using Strata.SqlTools.EFCore.Abstractions;
+using Strata.SqlTools.EFCore.Services;
+
+namespace Strata.SqlTools.EFCore.Tests;
+
+[TestFixture]
+public class QueryBreakdownRepositoryTests
+{
+    private DbContext _dbContext = null!;
+    private IQueryBreakdownMapper _mapper = null!;
+    private IQueryBreakdownRepository _repository = null!;
+
+    [SetUp]
+    public void Setup()
+    {
+        var options = new DbContextOptionsBuilder()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+
+        _dbContext = new TestDbContext(options);
+        _dbContext.Database.EnsureCreated();
+
+        _mapper = new QueryBreakdownMapper();
+        _repository = new QueryBreakdownRepository(_dbContext, _mapper);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        _dbContext.Dispose();
+    }
+
+    [Test]
+    public async Task AddAsync_WithValidQuery_ReturnsValidId()
+    {
+        // Arrange
+        var queryBreakdown = new QueryBreakdown("ID, Name", "Users");
+
+        // Act
+        int id = await _repository.AddAsync(queryBreakdown);
+
+        // Assert
+        Assert.That(id, Is.GreaterThan(0));
+    }
+
+    [Test]
+    public async Task GetByIdAsync_WithExistingId_ReturnsQueryBreakdown()
+    {
+        // Arrange
+        var queryBreakdown = new QueryBreakdown("ID, Name", "Users");
+        int id = await _repository.AddAsync(queryBreakdown);
+
+        // Act
+        var retrieved = await _repository.GetByIdAsync(id);
+
+        // Assert
+        Assert.That(retrieved, Is.Not.Null);
+        Assert.That(retrieved?.SelectClause?.Clause, Is.EqualTo("ID, Name"));
+        Assert.That(retrieved?.FromClause?.Clause, Is.EqualTo("Users"));
+    }
+
+    [Test]
+    public async Task GetByIdAsync_WithNonExistentId_ReturnsNull()
+    {
+        // Act
+        var retrieved = await _repository.GetByIdAsync(999);
+
+        // Assert
+        Assert.That(retrieved, Is.Null);
+    }
+
+    [Test]
+    public async Task GetAllAsync_WithMultipleQueries_ReturnsAllQueries()
+    {
+        // Arrange
+        var query1 = new QueryBreakdown("ID", "Users");
+        var query2 = new QueryBreakdown("OrderID, Total", "Orders");
+
+        await _repository.AddAsync(query1);
+        await _repository.AddAsync(query2);
+
+        // Act
+        var allQueries = await _repository.GetAllAsync();
+
+        // Assert
+        Assert.That(allQueries, Has.Count.EqualTo(2));
+    }
+
+    [Test]
+    public async Task UpdateAsync_WithExistingQuery_UpdatesData()
+    {
+        // Arrange
+        var queryBreakdown = new QueryBreakdown("ID, Name", "Users");
+        int id = await _repository.AddAsync(queryBreakdown);
+
+        var updatedQuery = new QueryBreakdown("ID, Name, Email", "Users");
+
+        // Act
+        await _repository.UpdateAsync(id, updatedQuery);
+        var retrieved = await _repository.GetByIdAsync(id);
+
+        // Assert
+        Assert.That(retrieved?.SelectClause?.Clause, Is.EqualTo("ID, Name, Email"));
+    }
+
+    [Test]
+    public async Task DeleteAsync_WithExistingId_DeletesQuery()
+    {
+        // Arrange
+        var queryBreakdown = new QueryBreakdown("ID, Name", "Users");
+        int id = await _repository.AddAsync(queryBreakdown);
+
+        // Act
+        bool deleted = await _repository.DeleteAsync(id);
+        var retrieved = await _repository.GetByIdAsync(id);
+
+        // Assert
+        Assert.That(deleted, Is.True);
+        Assert.That(retrieved, Is.Null);
+    }
+
+    [Test]
+    public async Task DeleteAsync_WithNonExistentId_ReturnsFalse()
+    {
+        // Act
+        bool deleted = await _repository.DeleteAsync(999);
+
+        // Assert
+        Assert.That(deleted, Is.False);
+    }
+
+    [Test]
+    public async Task GetCountAsync_WithMultipleQueries_ReturnsCorrectCount()
+    {
+        // Arrange
+        await _repository.AddAsync(new QueryBreakdown("ID", "Users"));
+        await _repository.AddAsync(new QueryBreakdown("OrderID", "Orders"));
+        await _repository.AddAsync(new QueryBreakdown("ProductID", "Products"));
+
+        // Act
+        int count = await _repository.GetCountAsync();
+
+        // Assert
+        Assert.That(count, Is.EqualTo(3));
+    }
+
+    [Test]
+    public async Task AddAsync_WithParameters_PersistsParameters()
+    {
+        // Arrange
+        var queryBreakdown = new QueryBreakdown("ID, Name", "Users");
+        queryBreakdown.AddParameter("UserId", 123);
+
+        // Act
+        int id = await _repository.AddAsync(queryBreakdown);
+        var retrieved = await _repository.GetByIdAsync(id);
+
+        // Assert
+        Assert.That(retrieved?.Parameters, Does.ContainKey("@UserId"));
+    }
+}
@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <LangVersion>latest</LangVersion>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="NUnit" Version="3.14.0" />
+    <PackageReference Include="NUnit.Analyzers" Version="3.9.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="8.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="NUnit.Framework" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Strata.SqlTools.SqlBreakdown\Strata.SqlTools.SqlBreakdown.csproj" />
+    <ProjectReference Include="..\..\src\Strata.SqlTools.SqlServer\Strata.SqlTools.SqlServer.csproj" />
+    <ProjectReference Include="..\..\src\Strata.SqlTools.EFCore\Strata.SqlTools.EFCore.csproj" />
+  </ItemGroup>
+
+</Project>
@@ -0,0 +1,26 @@
+using Microsoft.EntityFrameworkCore;
+using Strata.SqlTools.EFCore.Configurations;
+using Strata.SqlTools.EFCore.Models;
+using Strata.SqlTools.EFCore.Services;
+
+namespace Strata.SqlTools.EFCore.Tests;
+
+/// <summary>
+/// Test DbContext for in-memory testing of QueryBreakdown entities.
+/// </summary>
+public class TestDbContext : DbContext
+{
+    public DbSet<QueryBreakdownEntity> QueryBreakdowns { get; set; } = null!;
+    public DbSet<QueryParameterEntity> QueryParameters { get; set; } = null!;
+    public DbSet<WithClauseEntity> WithClauses { get; set; } = null!;
+
+    public TestDbContext(DbContextOptions options) : base(options)
+    {
+    }
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        base.OnModelCreating(modelBuilder);
+        modelBuilder.ConfigureQueryBreakdownEntities();
+    }
+}