@polymorphism-tech/morph-spec 4.12.0 → 4.14.0

package/framework/templates/code/dotnet/test.cs

@@ -1,238 +1,324 @@
 // ============================================================
-// TEST TEMPLATE
+// TEST TEMPLATE (VSA Pattern — Handler + Validator)
 // Generated by MORPH Framework
 // ============================================================
 
 using FluentAssertions;
+using FluentValidation;
+using FluentValidation.Results;
 using Microsoft.Extensions.Logging;
 using NSubstitute;
+using {{pascalCase PROJECT_NAME}}.Repository;
 using Xunit;
 
-namespace {{NAMESPACE}}.Tests.Unit.Features.{{pascalCase FEATURE_NAME}};
+namespace {{pascalCase PROJECT_NAME}}.Tests.Unit.Features.{{pascalCase FEATURE_NAME}};
+
+// ============================================================
+// Handler Tests
+// ============================================================
 
 /// <summary>
-/// Unit tests for {{pascalCase FEATURE_NAME}}Service.
+/// Unit tests for {{pascalCase FEATURE_NAME}} handlers.
+/// Tests handlers directly with mocked IRepository and IUnitOfWork.
 /// </summary>
-public class {{pascalCase FEATURE_NAME}}ServiceTests
+public class {{pascalCase FEATURE_NAME}}HandlerTests
 {
-    private readonly I{{pascalCase FEATURE_NAME}}Repository _repository;
-    private readonly ILogger<{{pascalCase FEATURE_NAME}}Service> _logger;
-    private readonly {{pascalCase FEATURE_NAME}}Service _sut;
+    private readonly IRepository<{{pascalCase FEATURE_NAME}}> _repository;
+    private readonly IUnitOfWork _unitOfWork;
+    private readonly ILogger<Create{{pascalCase FEATURE_NAME}}.Handler> _logger;
 
-    public {{pascalCase FEATURE_NAME}}ServiceTests()
+    public {{pascalCase FEATURE_NAME}}HandlerTests()
     {
-        _repository = Substitute.For<I{{pascalCase FEATURE_NAME}}Repository>();
-        _logger = Substitute.For<ILogger<{{pascalCase FEATURE_NAME}}Service>>();
-        _sut = new {{pascalCase FEATURE_NAME}}Service(_repository, _logger);
+        _repository = Substitute.For<IRepository<{{pascalCase FEATURE_NAME}}>>();
+        _unitOfWork = Substitute.For<IUnitOfWork>();
+        _logger = Substitute.For<ILogger<Create{{pascalCase FEATURE_NAME}}.Handler>>();
     }
 
-    #region GetByIdAsync Tests
+    #region Create Handler Tests
 
     [Fact]
-    public async Task GetByIdAsync_WithValidId_ReturnsDto()
+    public async Task Create_HandleAsync_WithValidCommand_ReturnsSuccessResult()
     {
         // Arrange
-        var id = 1;
-        var entity = CreateTestEntity(id, "Test {{pascalCase FEATURE_NAME}}");
-        _repository.GetByIdAsync(id, Arg.Any<CancellationToken>())
-            .Returns(entity);
+        var command = new Create{{pascalCase FEATURE_NAME}}.Command("Test {{pascalCase FEATURE_NAME}}");
+        var handler = new Create{{pascalCase FEATURE_NAME}}.Handler(_repository, _unitOfWork, _logger);
+
+        _repository.AddAsync(Arg.Any<{{pascalCase FEATURE_NAME}}>(), Arg.Any<CancellationToken>())
+            .Returns(callInfo => callInfo.Arg<{{pascalCase FEATURE_NAME}}>());
+
+        _unitOfWork.CommitAsync(Arg.Any<CancellationToken>())
+            .Returns(1);
 
         // Act
-        var result = await _sut.GetByIdAsync(id);
+        var result = await handler.HandleAsync(command, CancellationToken.None);
 
         // Assert
-        result.Should().NotBeNull();
-        result!.Id.Should().Be(id);
-        result.Name.Should().Be("Test {{pascalCase FEATURE_NAME}}");
+        result.IsSuccess.Should().BeTrue();
+        result.Value.Should().NotBeNull();
+        result.Value.Name.Should().Be("Test {{pascalCase FEATURE_NAME}}");
+
+        await _repository.Received(1).AddAsync(Arg.Any<{{pascalCase FEATURE_NAME}}>(), Arg.Any<CancellationToken>());
+        await _unitOfWork.Received(1).CommitAsync(Arg.Any<CancellationToken>());
     }
 
     [Fact]
-    public async Task GetByIdAsync_WithInvalidId_ReturnsNull()
+    public async Task Create_HandleAsync_WhenCommitFails_ReturnsFailureResult()
     {
         // Arrange
-        var id = 999;
-        _repository.GetByIdAsync(id, Arg.Any<CancellationToken>())
-            .Returns((Domain.Entities.{{pascalCase FEATURE_NAME}}?)null);
+        var command = new Create{{pascalCase FEATURE_NAME}}.Command("Test {{pascalCase FEATURE_NAME}}");
+        var handler = new Create{{pascalCase FEATURE_NAME}}.Handler(_repository, _unitOfWork, _logger);
+
+        _repository.AddAsync(Arg.Any<{{pascalCase FEATURE_NAME}}>(), Arg.Any<CancellationToken>())
+            .Returns(callInfo => callInfo.Arg<{{pascalCase FEATURE_NAME}}>());
+
+        _unitOfWork.CommitAsync(Arg.Any<CancellationToken>())
+            .ThrowsAsync(new InvalidOperationException("Database error"));
 
         // Act
-        var result = await _sut.GetByIdAsync(id);
+        var act = async () => await handler.HandleAsync(command, CancellationToken.None);
 
         // Assert
-        result.Should().BeNull();
+        await act.Should().ThrowAsync<InvalidOperationException>()
+            .WithMessage("Database error");
     }
 
     #endregion
 
-    #region GetAllAsync Tests
+    #region GetById Handler Tests
 
     [Fact]
-    public async Task GetAllAsync_ReturnsAllItems()
+    public async Task GetById_HandleAsync_WithValidId_ReturnsSuccessResult()
     {
         // Arrange
-        var entities = new List<Domain.Entities.{{pascalCase FEATURE_NAME}}>
-        {
-            CreateTestEntity(1, "First"),
-            CreateTestEntity(2, "Second"),
-            CreateTestEntity(3, "Third")
-        };
-        _repository.GetAllAsync(Arg.Any<CancellationToken>())
-            .Returns(entities);
+        var query = new GetById{{pascalCase FEATURE_NAME}}.Query(1);
+        var entity = CreateTestEntity(1, "Test {{pascalCase FEATURE_NAME}}");
+        var handler = new GetById{{pascalCase FEATURE_NAME}}.Handler(_repository);
+
+        _repository.GetByIdAsync(1, Arg.Any<CancellationToken>())
+            .Returns(entity);
 
         // Act
-        var result = await _sut.GetAllAsync();
+        var result = await handler.HandleAsync(query, CancellationToken.None);
 
         // Assert
-        result.Should().HaveCount(3);
-        result[0].Name.Should().Be("First");
+        result.IsSuccess.Should().BeTrue();
+        result.Value.Should().NotBeNull();
+        result.Value!.Name.Should().Be("Test {{pascalCase FEATURE_NAME}}");
     }
 
     [Fact]
-    public async Task GetAllAsync_WithNoItems_ReturnsEmptyList()
+    public async Task GetById_HandleAsync_WithInvalidId_ReturnsFailureResult()
     {
         // Arrange
-        _repository.GetAllAsync(Arg.Any<CancellationToken>())
-            .Returns(new List<Domain.Entities.{{pascalCase FEATURE_NAME}}>());
+        var query = new GetById{{pascalCase FEATURE_NAME}}.Query(999);
+        var handler = new GetById{{pascalCase FEATURE_NAME}}.Handler(_repository);
+
+        _repository.GetByIdAsync(999, Arg.Any<CancellationToken>())
+            .Returns(({{pascalCase FEATURE_NAME}}?)null);
 
         // Act
-        var result = await _sut.GetAllAsync();
+        var result = await handler.HandleAsync(query, CancellationToken.None);
 
         // Assert
-        result.Should().BeEmpty();
+        result.IsSuccess.Should().BeFalse();
     }
 
     #endregion
 
-    #region CreateAsync Tests
+    #region Update Handler Tests
 
     [Fact]
-    public async Task CreateAsync_WithValidRequest_CreatesAndReturnsDto()
+    public async Task Update_HandleAsync_WithValidCommand_ReturnsSuccessResult()
     {
         // Arrange
-        var request = new Create{{pascalCase FEATURE_NAME}}Request("New {{pascalCase FEATURE_NAME}}");
+        var command = new Update{{pascalCase FEATURE_NAME}}.Command(1, "Updated Name");
+        var entity = CreateTestEntity(1, "Original Name");
+        var handler = new Update{{pascalCase FEATURE_NAME}}.Handler(_repository, _unitOfWork);
+
+        _repository.GetByIdAsync(1, Arg.Any<CancellationToken>())
+            .Returns(entity);
 
-        _repository
-            .When(x => x.AddAsync(Arg.Any<Domain.Entities.{{pascalCase FEATURE_NAME}}>(), Arg.Any<CancellationToken>()))
-            .Do(x =>
-            {
-                // Simulate ID assignment
-                var entity = x.Arg<Domain.Entities.{{pascalCase FEATURE_NAME}}>();
-                // entity.Id would be set by EF Core
-            });
+        _unitOfWork.CommitAsync(Arg.Any<CancellationToken>())
+            .Returns(1);
 
         // Act
-        var result = await _sut.CreateAsync(request);
+        var result = await handler.HandleAsync(command, CancellationToken.None);
 
         // Assert
-        result.Should().NotBeNull();
-        result.Name.Should().Be("New {{pascalCase FEATURE_NAME}}");
+        result.IsSuccess.Should().BeTrue();
 
-        await _repository.Received(1).AddAsync(Arg.Any<Domain.Entities.{{pascalCase FEATURE_NAME}}>(), Arg.Any<CancellationToken>());
-        await _repository.Received(1).SaveChangesAsync(Arg.Any<CancellationToken>());
+        await _repository.Received(1).UpdateAsync(Arg.Any<{{pascalCase FEATURE_NAME}}>(), Arg.Any<CancellationToken>());
+        await _unitOfWork.Received(1).CommitAsync(Arg.Any<CancellationToken>());
     }
 
-    [Theory]
-    [InlineData("")]
-    [InlineData(" ")]
-    [InlineData(null)]
-    public async Task CreateAsync_WithInvalidName_ThrowsValidationException(string? name)
+    [Fact]
+    public async Task Update_HandleAsync_WithNonExistentId_ReturnsFailureResult()
     {
         // Arrange
-        var request = new Create{{pascalCase FEATURE_NAME}}Request(name!);
+        var command = new Update{{pascalCase FEATURE_NAME}}.Command(999, "Updated");
+        var handler = new Update{{pascalCase FEATURE_NAME}}.Handler(_repository, _unitOfWork);
+
+        _repository.GetByIdAsync(999, Arg.Any<CancellationToken>())
+            .Returns(({{pascalCase FEATURE_NAME}}?)null);
 
         // Act
-        var act = async () => await _sut.CreateAsync(request);
+        var result = await handler.HandleAsync(command, CancellationToken.None);
 
         // Assert
-        await act.Should().ThrowAsync<ValidationException>();
+        result.IsSuccess.Should().BeFalse();
+        await _unitOfWork.DidNotReceive().CommitAsync(Arg.Any<CancellationToken>());
     }
 
     #endregion
 
-    #region UpdateAsync Tests
+    #region Delete Handler Tests
 
     [Fact]
-    public async Task UpdateAsync_WithValidRequest_UpdatesEntity()
+    public async Task Delete_HandleAsync_WithValidId_ReturnsSuccessResult()
     {
         // Arrange
-        var id = 1;
-        var entity = CreateTestEntity(id, "Original");
-        var request = new Update{{pascalCase FEATURE_NAME}}Request("Updated");
+        var command = new Delete{{pascalCase FEATURE_NAME}}.Command(1);
+        var entity = CreateTestEntity(1, "To Delete");
+        var handler = new Delete{{pascalCase FEATURE_NAME}}.Handler(_repository, _unitOfWork);
 
-        _repository.GetByIdAsync(id, Arg.Any<CancellationToken>())
+        _repository.GetByIdAsync(1, Arg.Any<CancellationToken>())
             .Returns(entity);
 
+        _unitOfWork.CommitAsync(Arg.Any<CancellationToken>())
+            .Returns(1);
+
         // Act
-        await _sut.UpdateAsync(id, request);
+        var result = await handler.HandleAsync(command, CancellationToken.None);
 
         // Assert
-        _repository.Received(1).Update(Arg.Any<Domain.Entities.{{pascalCase FEATURE_NAME}}>());
-        await _repository.Received(1).SaveChangesAsync(Arg.Any<CancellationToken>());
+        result.IsSuccess.Should().BeTrue();
+
+        await _repository.Received(1).DeleteAsync(entity, Arg.Any<CancellationToken>());
+        await _unitOfWork.Received(1).CommitAsync(Arg.Any<CancellationToken>());
     }
 
     [Fact]
-    public async Task UpdateAsync_WithNonExistentId_ThrowsNotFoundException()
+    public async Task Delete_HandleAsync_WithNonExistentId_ReturnsFailureResult()
     {
         // Arrange
-        var id = 999;
-        var request = new Update{{pascalCase FEATURE_NAME}}Request("Updated");
+        var command = new Delete{{pascalCase FEATURE_NAME}}.Command(999);
+        var handler = new Delete{{pascalCase FEATURE_NAME}}.Handler(_repository, _unitOfWork);
 
-        _repository.GetByIdAsync(id, Arg.Any<CancellationToken>())
-            .Returns((Domain.Entities.{{pascalCase FEATURE_NAME}}?)null);
+        _repository.GetByIdAsync(999, Arg.Any<CancellationToken>())
+            .Returns(({{pascalCase FEATURE_NAME}}?)null);
 
         // Act
-        var act = async () => await _sut.UpdateAsync(id, request);
+        var result = await handler.HandleAsync(command, CancellationToken.None);
 
         // Assert
-        await act.Should().ThrowAsync<{{pascalCase FEATURE_NAME}}NotFoundException>();
+        result.IsSuccess.Should().BeFalse();
+        await _unitOfWork.DidNotReceive().CommitAsync(Arg.Any<CancellationToken>());
+    }
+
+    #endregion
+
+    #region Helper Methods
+
+    private static {{pascalCase FEATURE_NAME}} CreateTestEntity(int id, string name)
+    {
+        return {{pascalCase FEATURE_NAME}}.Create(name);
+        // Note: In real tests, use reflection or a test factory to set the Id
     }
 
     #endregion
+}
 
-    #region DeleteAsync Tests
+// ============================================================
+// Validator Tests
+// ============================================================
+
+/// <summary>
+/// Unit tests for {{pascalCase FEATURE_NAME}} validators.
+/// Tests FluentValidation rules using ValidateAsync.
+/// </summary>
+public class {{pascalCase FEATURE_NAME}}ValidatorTests
+{
+    #region Create Validator Tests
 
     [Fact]
-    public async Task DeleteAsync_WithValidId_DeletesEntity()
+    public async Task CreateValidator_WithValidCommand_PassesValidation()
     {
         // Arrange
-        var id = 1;
-        var entity = CreateTestEntity(id, "To Delete");
+        var validator = new Create{{pascalCase FEATURE_NAME}}.Validator();
+        var command = new Create{{pascalCase FEATURE_NAME}}.Command("Valid Name");
 
-        _repository.GetByIdAsync(id, Arg.Any<CancellationToken>())
-            .Returns(entity);
+        // Act
+        ValidationResult result = await validator.ValidateAsync(command);
+
+        // Assert
+        result.IsValid.Should().BeTrue();
+        result.Errors.Should().BeEmpty();
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData(" ")]
+    [InlineData(null)]
+    public async Task CreateValidator_WithInvalidName_FailsValidation(string? name)
+    {
+        // Arrange
+        var validator = new Create{{pascalCase FEATURE_NAME}}.Validator();
+        var command = new Create{{pascalCase FEATURE_NAME}}.Command(name!);
 
         // Act
-        await _sut.DeleteAsync(id);
+        ValidationResult result = await validator.ValidateAsync(command);
 
         // Assert
-        _repository.Received(1).Remove(entity);
-        await _repository.Received(1).SaveChangesAsync(Arg.Any<CancellationToken>());
+        result.IsValid.Should().BeFalse();
+        result.Errors.Should().Contain(e => e.PropertyName == nameof(Create{{pascalCase FEATURE_NAME}}.Command.Name));
     }
 
     [Fact]
-    public async Task DeleteAsync_WithNonExistentId_ThrowsNotFoundException()
+    public async Task CreateValidator_WithNameExceedingMaxLength_FailsValidation()
     {
         // Arrange
-        var id = 999;
-
-        _repository.GetByIdAsync(id, Arg.Any<CancellationToken>())
-            .Returns((Domain.Entities.{{pascalCase FEATURE_NAME}}?)null);
+        var validator = new Create{{pascalCase FEATURE_NAME}}.Validator();
+        var command = new Create{{pascalCase FEATURE_NAME}}.Command(new string('A', 201));
 
         // Act
-        var act = async () => await _sut.DeleteAsync(id);
+        ValidationResult result = await validator.ValidateAsync(command);
 
         // Assert
-        await act.Should().ThrowAsync<{{pascalCase FEATURE_NAME}}NotFoundException>();
+        result.IsValid.Should().BeFalse();
+        result.Errors.Should().Contain(e => e.PropertyName == nameof(Create{{pascalCase FEATURE_NAME}}.Command.Name));
     }
 
     #endregion
 
-    #region Helper Methods
+    #region Update Validator Tests
+
+    [Fact]
+    public async Task UpdateValidator_WithValidCommand_PassesValidation()
+    {
+        // Arrange
+        var validator = new Update{{pascalCase FEATURE_NAME}}.Validator();
+        var command = new Update{{pascalCase FEATURE_NAME}}.Command(1, "Updated Name");
+
+        // Act
+        ValidationResult result = await validator.ValidateAsync(command);
+
+        // Assert
+        result.IsValid.Should().BeTrue();
+    }
 
-    private static Domain.Entities.{{pascalCase FEATURE_NAME}} CreateTestEntity(int id, string name)
+    [Fact]
+    public async Task UpdateValidator_WithInvalidId_FailsValidation()
     {
-        return Domain.Entities.{{pascalCase FEATURE_NAME}}.Create(name);
-        // Note: In real tests, you might need reflection to set the Id
-        // or use a factory method that accepts an id for testing
+        // Arrange
+        var validator = new Update{{pascalCase FEATURE_NAME}}.Validator();
+        var command = new Update{{pascalCase FEATURE_NAME}}.Command(0, "Updated Name");
+
+        // Act
+        ValidationResult result = await validator.ValidateAsync(command);
+
+        // Assert
+        result.IsValid.Should().BeFalse();
+        result.Errors.Should().Contain(e => e.PropertyName == nameof(Update{{pascalCase FEATURE_NAME}}.Command.Id));
     }
 
     #endregion

package/framework/templates/context/ARCHITECTURE.md

@@ -0,0 +1,89 @@
+# {{projectName}} — Architecture Context
+
+> Auto-generated by `morph-spec context refresh`
+> Last updated: {{timestamp}}
+
+{{#if hasDotnet}}
+## .NET Entities ({{entityCount}})
+
+| Entity | Type | Path |
+|--------|------|------|
+{{#each entities}}
+| `{{name}}` | {{type}} | `{{path}}` |
+{{/each}}
+
+## API Endpoints ({{endpointCount}})
+
+| Endpoint | Method | Route | Path |
+|----------|--------|-------|------|
+{{#each endpoints}}
+| `{{name}}` | {{method}} | `{{route}}` | `{{path}}` |
+{{/each}}
+{{/if}}
+
+{{#if hasNextjs}}
+## Next.js Pages ({{pageCount}})
+
+| Route | Path |
+|-------|------|
+{{#each pages}}
+| `{{route}}` | `{{path}}` |
+{{/each}}
+
+{{#if layouts.length}}
+### Layouts
+
+{{#each layouts}}
+- `{{path}}`
+{{/each}}
+{{/if}}
+
+{{#if componentCount}}
+## Components ({{componentCount}})
+
+| Component | Path |
+|-----------|------|
+{{#each components}}
+| `{{name}}` | `{{path}}` |
+{{/each}}
+{{/if}}
+{{/if}}
+
+{{#if hasIntegrations}}
+## Integrations
+
+| Service | Type | Configured |
+|---------|------|------------|
+{{#each integrations}}
+| {{name}} | {{type}} | {{#if configured}}Yes{{else}}No{{/if}} |
+{{/each}}
+{{/if}}
+
+{{#if hasTables}}
+## Database Tables ({{tableCount}})
+
+| Table | Source Migration |
+|-------|----------------|
+{{#each tables}}
+| `{{table}}` | `{{migration}}` |
+{{/each}}
+{{/if}}
+
+{{#if hasDotnetPackages}}
+## .NET Packages
+
+{{#each dotnetPackages}}
+- `{{name}}` {{version}}
+{{/each}}
+{{/if}}
+
+{{#if hasNpmPackages}}
+## NPM Packages
+
+{{#each npmPackages}}
+- `{{name}}` {{version}}
+{{/each}}
+{{/if}}
+
+---
+*Generated by morph-spec v{{morphVersion}}*

package/framework/templates/context/CONTEXT-FEATURE.md

@@ -230,8 +230,8 @@ No validation runs yet. Validators run automatically via checkpoints.
 
 ### Continue Implementation
 ```bash
-# Start next task
-morph-spec task next {{FEATURE_NAME}}
+# Start a task (dispatch gate + state tracking)
+morph-spec task start {{FEATURE_NAME}} <task-id>
 
 # Complete current task (runs validators)
 morph-spec task done {{FEATURE_NAME}} {{CURRENT_TASK_ID}}