@atlashub/smartstack-cli 1.36.0 → 2.0.0

package/templates/mcp-scaffolding/tests/controller.test.cs.hbs

@@ -0,0 +1,413 @@
+{{!-- SmartStack Controller Test Template --}}
+{{!-- Generates integration tests for API controllers following SmartStack conventions --}}
+
+using FluentAssertions;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Microsoft.Extensions.DependencyInjection;
+using Moq;
+using System.Net;
+using System.Net.Http.Json;
+using Xunit;
+using {{namespace}}.Api;
+using {{namespace}}.Api.Controllers;
+using {{namespace}}.Application.DTOs;
+using {{namespace}}.Application.Interfaces;
+using {{namespace}}.Domain.Entities;
+
+namespace {{namespace}}.Tests.Integration.Controllers;
+
+/// <summary>
+/// Integration tests for <see cref="{{name}}Controller"/>.
+/// Follows SmartStack testing conventions: {Method}_When{Condition}_Should{Result}
+/// </summary>
+public class {{name}}ControllerTests : IClassFixture<WebApplicationFactory<Program>>
+{
+    private readonly WebApplicationFactory<Program> _factory;
+    private readonly HttpClient _client;
+    private readonly Mock<I{{name}}Service> _mockService;
+
+    public {{name}}ControllerTests(WebApplicationFactory<Program> factory)
+    {
+        _mockService = new Mock<I{{name}}Service>();
+
+        _factory = factory.WithWebHostBuilder(builder =>
+        {
+            builder.ConfigureServices(services =>
+            {
+                // Remove the real service and add mock
+                var descriptor = services.SingleOrDefault(
+                    d => d.ServiceType == typeof(I{{name}}Service));
+                if (descriptor != null)
+                    services.Remove(descriptor);
+
+                services.AddScoped(_ => _mockService.Object);
+            });
+        });
+
+        _client = _factory.CreateClient();
+    }
+
+    #region GET Tests
+
+    [Fact]
+    public async Task GetAll_WhenCalled_ShouldReturn200WithList()
+    {
+        // Arrange
+        var items = new List<{{name}}Response>
+        {
+            new() { Id = Guid.NewGuid(), Code = "TEST-001" },
+            new() { Id = Guid.NewGuid(), Code = "TEST-002" }
+        };
+        _mockService.Setup(x => x.GetAllAsync(It.IsAny<CancellationToken>()))
+            .ReturnsAsync(items);
+
+        // Act
+        var response = await _client.GetAsync("/api/{{lowerName}}");
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.OK);
+        var result = await response.Content.ReadFromJsonAsync<List<{{name}}Response>>();
+        result.Should().HaveCount(2);
+    }
+
+    [Fact]
+    public async Task GetById_WhenExists_ShouldReturn200()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        var item = new {{name}}Response { Id = id, Code = "TEST-001" };
+        _mockService.Setup(x => x.GetByIdAsync(id, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(item);
+
+        // Act
+        var response = await _client.GetAsync($"/api/{{lowerName}}/{id}");
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.OK);
+        var result = await response.Content.ReadFromJsonAsync<{{name}}Response>();
+        result!.Id.Should().Be(id);
+    }
+
+    [Fact]
+    public async Task GetById_WhenNotExists_ShouldReturn404()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        _mockService.Setup(x => x.GetByIdAsync(id, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(({{name}}Response?)null);
+
+        // Act
+        var response = await _client.GetAsync($"/api/{{lowerName}}/{id}");
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.NotFound);
+    }
+
+    #endregion
+
+    #region POST Tests
+
+    [Fact]
+    public async Task Create_WhenValidData_ShouldReturn201()
+    {
+        // Arrange
+        var request = new Create{{name}}Request { Code = "NEW-001" };
+        var created = new {{name}}Response { Id = Guid.NewGuid(), Code = request.Code };
+        _mockService.Setup(x => x.CreateAsync(It.IsAny<Create{{name}}Request>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(created);
+
+        // Act
+        var response = await _client.PostAsJsonAsync("/api/{{lowerName}}", request);
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.Created);
+        response.Headers.Location.Should().NotBeNull();
+        var result = await response.Content.ReadFromJsonAsync<{{name}}Response>();
+        result!.Code.Should().Be(request.Code);
+    }
+
+    [Fact]
+    public async Task Create_WhenInvalidData_ShouldReturn400()
+    {
+        // Arrange
+        var request = new Create{{name}}Request { Code = "" }; // Invalid
+
+        // Act
+        var response = await _client.PostAsJsonAsync("/api/{{lowerName}}", request);
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
+    }
+
+    [Fact]
+    public async Task Create_WhenDuplicate_ShouldReturn409()
+    {
+        // Arrange
+        var request = new Create{{name}}Request { Code = "EXISTING" };
+        _mockService.Setup(x => x.CreateAsync(It.IsAny<Create{{name}}Request>(), It.IsAny<CancellationToken>()))
+            .ThrowsAsync(new BusinessException("Code already exists"));
+
+        // Act
+        var response = await _client.PostAsJsonAsync("/api/{{lowerName}}", request);
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.Conflict);
+    }
+
+    #endregion
+
+    #region PUT Tests
+
+    [Fact]
+    public async Task Update_WhenValidData_ShouldReturn200()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        var request = new Update{{name}}Request { /* properties */ };
+        var updated = new {{name}}Response { Id = id, Code = "UPDATED" };
+        _mockService.Setup(x => x.UpdateAsync(id, It.IsAny<Update{{name}}Request>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(updated);
+
+        // Act
+        var response = await _client.PutAsJsonAsync($"/api/{{lowerName}}/{id}", request);
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.OK);
+    }
+
+    [Fact]
+    public async Task Update_WhenNotExists_ShouldReturn404()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        var request = new Update{{name}}Request();
+        _mockService.Setup(x => x.UpdateAsync(id, It.IsAny<Update{{name}}Request>(), It.IsAny<CancellationToken>()))
+            .ThrowsAsync(new NotFoundException($"{{name}} {id} not found"));
+
+        // Act
+        var response = await _client.PutAsJsonAsync($"/api/{{lowerName}}/{id}", request);
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.NotFound);
+    }
+
+    [Fact]
+    public async Task Update_WhenConcurrencyConflict_ShouldReturn409()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        var request = new Update{{name}}Request();
+        _mockService.Setup(x => x.UpdateAsync(id, It.IsAny<Update{{name}}Request>(), It.IsAny<CancellationToken>()))
+            .ThrowsAsync(new ConcurrencyException("Concurrency conflict"));
+
+        // Act
+        var response = await _client.PutAsJsonAsync($"/api/{{lowerName}}/{id}", request);
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.Conflict);
+    }
+
+    #endregion
+
+    #region DELETE Tests
+
+    [Fact]
+    public async Task Delete_WhenExists_ShouldReturn204()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        _mockService.Setup(x => x.DeleteAsync(id, It.IsAny<CancellationToken>()))
+            .Returns(Task.CompletedTask);
+
+        // Act
+        var response = await _client.DeleteAsync($"/api/{{lowerName}}/{id}");
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.NoContent);
+    }
+
+    [Fact]
+    public async Task Delete_WhenNotExists_ShouldReturn404()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        _mockService.Setup(x => x.DeleteAsync(id, It.IsAny<CancellationToken>()))
+            .ThrowsAsync(new NotFoundException($"{{name}} {id} not found"));
+
+        // Act
+        var response = await _client.DeleteAsync($"/api/{{lowerName}}/{id}");
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.NotFound);
+    }
+
+    #endregion
+
+    {{#if includeAuthorization}}
+    #region Authorization Tests
+
+    [Fact]
+    public async Task GetAll_WhenUnauthorized_ShouldReturn401()
+    {
+        // Arrange
+        var unauthenticatedClient = _factory.CreateClient();
+        // Don't add auth header
+
+        // Act
+        var response = await unauthenticatedClient.GetAsync("/api/{{lowerName}}");
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.Unauthorized);
+    }
+
+    [Fact]
+    public async Task Create_WhenForbidden_ShouldReturn403()
+    {
+        // Arrange - User without create permission
+        var request = new Create{{name}}Request { Code = "TEST" };
+
+        // Act
+        var response = await _client.PostAsJsonAsync("/api/{{lowerName}}", request);
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.Forbidden);
+    }
+
+    [Fact]
+    public async Task Delete_WhenNotAdmin_ShouldReturn403()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+
+        // Act
+        var response = await _client.DeleteAsync($"/api/{{lowerName}}/{id}");
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.Forbidden);
+    }
+
+    #endregion
+    {{/if}}
+
+    {{#unless isSystemEntity}}
+    #region Tenant Isolation Tests
+
+    [Fact]
+    public async Task GetAll_ShouldOnlyReturnCurrentTenantData()
+    {
+        // Arrange
+        var tenantAId = Guid.NewGuid();
+        var tenantAItems = new List<{{name}}Response>
+        {
+            new() { Id = Guid.NewGuid(), TenantId = tenantAId, Code = "A-001" }
+        };
+        _mockService.Setup(x => x.GetAllAsync(It.IsAny<CancellationToken>()))
+            .ReturnsAsync(tenantAItems);
+
+        // Act
+        var response = await _client.GetAsync("/api/{{lowerName}}");
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.OK);
+        var result = await response.Content.ReadFromJsonAsync<List<{{name}}Response>>();
+        result.Should().OnlyContain(x => x.TenantId == tenantAId);
+    }
+
+    [Fact]
+    public async Task GetById_WhenDifferentTenant_ShouldReturn404()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        // Entity belongs to different tenant
+        _mockService.Setup(x => x.GetByIdAsync(id, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(({{name}}Response?)null);
+
+        // Act
+        var response = await _client.GetAsync($"/api/{{lowerName}}/{id}");
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.NotFound);
+    }
+
+    #endregion
+    {{/unless}}
+
+    #region Validation Tests
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    [InlineData("   ")]
+    public async Task Create_WhenInvalidCode_ShouldReturn400(string? invalidCode)
+    {
+        // Arrange
+        var request = new Create{{name}}Request { Code = invalidCode! };
+
+        // Act
+        var response = await _client.PostAsJsonAsync("/api/{{lowerName}}", request);
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
+    }
+
+    [Fact]
+    public async Task Create_WhenCodeTooLong_ShouldReturn400()
+    {
+        // Arrange
+        var request = new Create{{name}}Request
+        {
+            Code = new string('A', 256) // Exceeds max length
+        };
+
+        // Act
+        var response = await _client.PostAsJsonAsync("/api/{{lowerName}}", request);
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
+    }
+
+    #endregion
+
+    #region Pagination Tests
+
+    [Fact]
+    public async Task GetAll_WithPagination_ShouldReturnPagedResults()
+    {
+        // Arrange
+        var items = Enumerable.Range(1, 100)
+            .Select(i => new {{name}}Response { Id = Guid.NewGuid(), Code = $"TEST-{i:D3}" })
+            .ToList();
+        _mockService.Setup(x => x.GetAllAsync(It.IsAny<CancellationToken>()))
+            .ReturnsAsync(items.Take(10).ToList());
+
+        // Act
+        var response = await _client.GetAsync("/api/{{lowerName}}?page=1&pageSize=10");
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.OK);
+        var result = await response.Content.ReadFromJsonAsync<List<{{name}}Response>>();
+        result.Should().HaveCount(10);
+    }
+
+    #endregion
+
+    #region Error Response Format Tests
+
+    [Fact]
+    public async Task Create_WhenValidationFails_ShouldReturnProblemDetails()
+    {
+        // Arrange
+        var request = new Create{{name}}Request { Code = "" };
+
+        // Act
+        var response = await _client.PostAsJsonAsync("/api/{{lowerName}}", request);
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
+        var problemDetails = await response.Content.ReadFromJsonAsync<ProblemDetails>();
+        problemDetails.Should().NotBeNull();
+        problemDetails!.Status.Should().Be(400);
+    }
+
+    #endregion
+}

package/templates/mcp-scaffolding/tests/entity.test.cs.hbs

@@ -0,0 +1,239 @@
+{{!-- SmartStack Entity Test Template --}}
+{{!-- Generates unit tests for domain entities following SmartStack conventions --}}
+
+using FluentAssertions;
+using Xunit;
+using {{namespace}}.Domain.Entities;
+
+namespace {{namespace}}.Tests.Unit.Domain;
+
+/// <summary>
+/// Unit tests for <see cref="{{name}}"/> entity.
+/// Follows SmartStack testing conventions: {Method}_When{Condition}_Should{Result}
+/// </summary>
+public class {{name}}Tests
+{
+    #region Factory Method Tests
+
+    [Fact]
+    public void Create_WhenValidData_ShouldCreateEntity()
+    {
+        // Arrange
+        {{#unless isSystemEntity}}
+        var tenantId = Guid.NewGuid();
+        {{/unless}}
+        var code = "TEST-001";
+        var createdBy = "test@example.com";
+
+        // Act
+        var result = {{name}}.Create({{#unless isSystemEntity}}tenantId, {{/unless}}code, createdBy);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Code.Should().Be(code);
+        {{#unless isSystemEntity}}
+        result.TenantId.Should().Be(tenantId);
+        {{/unless}}
+        result.CreatedBy.Should().Be(createdBy);
+        result.CreatedAt.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(1));
+    }
+
+    {{#unless isSystemEntity}}
+    [Fact]
+    public void Create_WhenEmptyTenantId_ShouldThrowException()
+    {
+        // Arrange
+        var tenantId = Guid.Empty;
+        var code = "TEST-001";
+
+        // Act
+        var act = () => {{name}}.Create(tenantId, code);
+
+        // Assert
+        act.Should().Throw<ArgumentException>()
+           .WithMessage("*TenantId*");
+    }
+    {{/unless}}
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    [InlineData("   ")]
+    public void Create_WhenInvalidCode_ShouldThrowException(string? invalidCode)
+    {
+        // Arrange
+        {{#unless isSystemEntity}}
+        var tenantId = Guid.NewGuid();
+        {{/unless}}
+
+        // Act
+        var act = () => {{name}}.Create({{#unless isSystemEntity}}tenantId, {{/unless}}invalidCode!);
+
+        // Assert
+        act.Should().Throw<ArgumentException>();
+    }
+
+    #endregion
+
+    #region Update Tests
+
+    [Fact]
+    public void Update_WhenValidData_ShouldUpdateEntity()
+    {
+        // Arrange
+        var entity = CreateValid{{name}}();
+        var updatedBy = "updater@example.com";
+
+        // Act
+        entity.Update(updatedBy);
+
+        // Assert
+        entity.UpdatedBy.Should().Be(updatedBy);
+        entity.UpdatedAt.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(1));
+    }
+
+    #endregion
+
+    {{#if includeSoftDelete}}
+    #region Soft Delete Tests
+
+    [Fact]
+    public void SoftDelete_WhenNotDeleted_ShouldMarkAsDeleted()
+    {
+        // Arrange
+        var entity = CreateValid{{name}}();
+        var deletedBy = "deleter@example.com";
+
+        // Act
+        entity.SoftDelete(deletedBy);
+
+        // Assert
+        entity.IsDeleted.Should().BeTrue();
+        entity.DeletedBy.Should().Be(deletedBy);
+        entity.DeletedAt.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(1));
+    }
+
+    [Fact]
+    public void SoftDelete_WhenAlreadyDeleted_ShouldThrowException()
+    {
+        // Arrange
+        var entity = CreateValid{{name}}();
+        entity.SoftDelete("first@example.com");
+
+        // Act
+        var act = () => entity.SoftDelete("second@example.com");
+
+        // Assert
+        act.Should().Throw<InvalidOperationException>()
+           .WithMessage("*already deleted*");
+    }
+
+    [Fact]
+    public void Restore_WhenDeleted_ShouldRestoreEntity()
+    {
+        // Arrange
+        var entity = CreateValid{{name}}();
+        entity.SoftDelete("deleter@example.com");
+        var restoredBy = "restorer@example.com";
+
+        // Act
+        entity.Restore(restoredBy);
+
+        // Assert
+        entity.IsDeleted.Should().BeFalse();
+        entity.DeletedBy.Should().BeNull();
+        entity.DeletedAt.Should().BeNull();
+        entity.UpdatedBy.Should().Be(restoredBy);
+    }
+
+    #endregion
+    {{/if}}
+
+    {{#if includeAudit}}
+    #region Audit Trail Tests
+
+    [Fact]
+    public void Create_ShouldSetAuditFields()
+    {
+        // Arrange
+        {{#unless isSystemEntity}}
+        var tenantId = Guid.NewGuid();
+        {{/unless}}
+        var createdBy = "creator@example.com";
+
+        // Act
+        var entity = {{name}}.Create({{#unless isSystemEntity}}tenantId, {{/unless}}"TEST", createdBy);
+
+        // Assert
+        entity.CreatedAt.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(1));
+        entity.CreatedBy.Should().Be(createdBy);
+        entity.UpdatedAt.Should().BeNull();
+        entity.UpdatedBy.Should().BeNull();
+    }
+
+    [Fact]
+    public void Update_ShouldSetUpdateAuditFields()
+    {
+        // Arrange
+        var entity = CreateValid{{name}}();
+        var originalCreatedAt = entity.CreatedAt;
+        var originalCreatedBy = entity.CreatedBy;
+        var updatedBy = "updater@example.com";
+
+        // Act
+        entity.Update(updatedBy);
+
+        // Assert
+        entity.CreatedAt.Should().Be(originalCreatedAt);
+        entity.CreatedBy.Should().Be(originalCreatedBy);
+        entity.UpdatedAt.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(1));
+        entity.UpdatedBy.Should().Be(updatedBy);
+    }
+
+    #endregion
+    {{/if}}
+
+    {{#unless isSystemEntity}}
+    #region Tenant Isolation Tests
+
+    [Fact]
+    public void TenantId_ShouldBeImmutable()
+    {
+        // Arrange
+        var tenantId = Guid.NewGuid();
+        var entity = {{name}}.Create(tenantId, "TEST");
+
+        // Assert - TenantId should not have a public setter
+        typeof({{name}}).GetProperty("TenantId")!
+            .SetMethod.Should().BeNull("TenantId should be immutable");
+    }
+
+    [Fact]
+    public void Create_WhenValidTenantId_ShouldStoreTenantId()
+    {
+        // Arrange
+        var tenantId = Guid.NewGuid();
+
+        // Act
+        var entity = {{name}}.Create(tenantId, "TEST");
+
+        // Assert
+        entity.TenantId.Should().Be(tenantId);
+    }
+
+    #endregion
+    {{/unless}}
+
+    #region Helper Methods
+
+    private static {{name}} CreateValid{{name}}()
+    {
+        {{#if isSystemEntity}}
+        return {{name}}.Create("TEST-001", "test@example.com");
+        {{else}}
+        return {{name}}.Create(Guid.NewGuid(), "TEST-001", "test@example.com");
+        {{/if}}
+    }
+
+    #endregion
+}