@atlashub/smartstack-cli 1.36.0 → 2.0.0

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

@@ -0,0 +1,390 @@
+{{!-- SmartStack Service Test Template --}}
+{{!-- Generates unit tests for application services following SmartStack conventions --}}
+
+using FluentAssertions;
+using Moq;
+using Xunit;
+using {{namespace}}.Application.Services;
+using {{namespace}}.Application.Interfaces;
+using {{namespace}}.Domain.Entities;
+using {{namespace}}.Domain.Interfaces;
+
+namespace {{namespace}}.Tests.Unit.Services;
+
+/// <summary>
+/// Unit tests for <see cref="{{name}}Service"/>.
+/// Follows SmartStack testing conventions: {Method}_When{Condition}_Should{Result}
+/// </summary>
+public class {{name}}ServiceTests
+{
+    private readonly Mock<I{{name}}Repository> _mockRepository;
+    private readonly Mock<IUnitOfWork> _mockUnitOfWork;
+    {{#unless isSystemEntity}}
+    private readonly Mock<ITenantContext> _mockTenantContext;
+    {{/unless}}
+    private readonly {{name}}Service _sut;
+
+    public {{name}}ServiceTests()
+    {
+        _mockRepository = new Mock<I{{name}}Repository>();
+        _mockUnitOfWork = new Mock<IUnitOfWork>();
+        {{#unless isSystemEntity}}
+        _mockTenantContext = new Mock<ITenantContext>();
+        _mockTenantContext.Setup(x => x.TenantId).Returns(Guid.NewGuid());
+        {{/unless}}
+
+        _sut = new {{name}}Service(
+            _mockRepository.Object,
+            _mockUnitOfWork.Object{{#unless isSystemEntity}},
+            _mockTenantContext.Object{{/unless}}
+        );
+    }
+
+    #region GetById Tests
+
+    [Fact]
+    public async Task GetByIdAsync_WhenExists_ShouldReturnEntity()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        var entity = CreateValid{{name}}(id);
+        _mockRepository.Setup(x => x.GetByIdAsync(id, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(entity);
+
+        // Act
+        var result = await _sut.GetByIdAsync(id);
+
+        // Assert
+        result.Should().NotBeNull();
+        result!.Id.Should().Be(id);
+    }
+
+    [Fact]
+    public async Task GetByIdAsync_WhenNotExists_ShouldReturnNull()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        _mockRepository.Setup(x => x.GetByIdAsync(id, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(({{name}}?)null);
+
+        // Act
+        var result = await _sut.GetByIdAsync(id);
+
+        // Assert
+        result.Should().BeNull();
+    }
+
+    #endregion
+
+    #region GetAll Tests
+
+    [Fact]
+    public async Task GetAllAsync_WhenEntitiesExist_ShouldReturnAll()
+    {
+        // Arrange
+        var entities = new List<{{name}}>
+        {
+            CreateValid{{name}}(),
+            CreateValid{{name}}()
+        };
+        _mockRepository.Setup(x => x.GetAllAsync(It.IsAny<CancellationToken>()))
+            .ReturnsAsync(entities);
+
+        // Act
+        var result = await _sut.GetAllAsync();
+
+        // Assert
+        result.Should().HaveCount(2);
+    }
+
+    [Fact]
+    public async Task GetAllAsync_WhenNoEntities_ShouldReturnEmptyList()
+    {
+        // Arrange
+        _mockRepository.Setup(x => x.GetAllAsync(It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new List<{{name}}>());
+
+        // Act
+        var result = await _sut.GetAllAsync();
+
+        // Assert
+        result.Should().BeEmpty();
+    }
+
+    #endregion
+
+    #region Create Tests
+
+    [Fact]
+    public async Task CreateAsync_WhenValidData_ShouldCreateAndReturnEntity()
+    {
+        // Arrange
+        var request = new Create{{name}}Request
+        {
+            Code = "NEW-001",
+            // Add other required properties
+        };
+
+        _mockRepository.Setup(x => x.AddAsync(It.IsAny<{{name}}>(), It.IsAny<CancellationToken>()))
+            .Returns(Task.CompletedTask);
+        _mockUnitOfWork.Setup(x => x.SaveChangesAsync(It.IsAny<CancellationToken>()))
+            .ReturnsAsync(1);
+
+        // Act
+        var result = await _sut.CreateAsync(request);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Code.Should().Be(request.Code);
+        _mockRepository.Verify(x => x.AddAsync(It.IsAny<{{name}}>(), It.IsAny<CancellationToken>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.SaveChangesAsync(It.IsAny<CancellationToken>()), Times.Once);
+    }
+
+    [Fact]
+    public async Task CreateAsync_WhenDuplicateCode_ShouldThrowException()
+    {
+        // Arrange
+        var request = new Create{{name}}Request { Code = "EXISTING-001" };
+        _mockRepository.Setup(x => x.ExistsByCodeAsync(request.Code, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(true);
+
+        // Act
+        var act = () => _sut.CreateAsync(request);
+
+        // Assert
+        await act.Should().ThrowAsync<BusinessException>()
+            .WithMessage("*already exists*");
+    }
+
+    #endregion
+
+    #region Update Tests
+
+    [Fact]
+    public async Task UpdateAsync_WhenExists_ShouldUpdateEntity()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        var entity = CreateValid{{name}}(id);
+        var request = new Update{{name}}Request
+        {
+            // Add properties to update
+        };
+
+        _mockRepository.Setup(x => x.GetByIdAsync(id, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(entity);
+        _mockUnitOfWork.Setup(x => x.SaveChangesAsync(It.IsAny<CancellationToken>()))
+            .ReturnsAsync(1);
+
+        // Act
+        var result = await _sut.UpdateAsync(id, request);
+
+        // Assert
+        result.Should().NotBeNull();
+        _mockUnitOfWork.Verify(x => x.SaveChangesAsync(It.IsAny<CancellationToken>()), Times.Once);
+    }
+
+    [Fact]
+    public async Task UpdateAsync_WhenNotExists_ShouldThrowException()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        var request = new Update{{name}}Request();
+        _mockRepository.Setup(x => x.GetByIdAsync(id, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(({{name}}?)null);
+
+        // Act
+        var act = () => _sut.UpdateAsync(id, request);
+
+        // Assert
+        await act.Should().ThrowAsync<NotFoundException>();
+    }
+
+    #endregion
+
+    #region Delete Tests
+
+    {{#if includeSoftDelete}}
+    [Fact]
+    public async Task DeleteAsync_WhenExists_ShouldSoftDelete()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        var entity = CreateValid{{name}}(id);
+        _mockRepository.Setup(x => x.GetByIdAsync(id, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(entity);
+        _mockUnitOfWork.Setup(x => x.SaveChangesAsync(It.IsAny<CancellationToken>()))
+            .ReturnsAsync(1);
+
+        // Act
+        await _sut.DeleteAsync(id);
+
+        // Assert
+        entity.IsDeleted.Should().BeTrue();
+        _mockUnitOfWork.Verify(x => x.SaveChangesAsync(It.IsAny<CancellationToken>()), Times.Once);
+    }
+
+    [Fact]
+    public async Task DeleteAsync_WhenAlreadyDeleted_ShouldThrowException()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        var entity = CreateValid{{name}}(id);
+        entity.SoftDelete("previous@example.com");
+        _mockRepository.Setup(x => x.GetByIdAsync(id, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(entity);
+
+        // Act
+        var act = () => _sut.DeleteAsync(id);
+
+        // Assert
+        await act.Should().ThrowAsync<BusinessException>()
+            .WithMessage("*already deleted*");
+    }
+    {{else}}
+    [Fact]
+    public async Task DeleteAsync_WhenExists_ShouldDelete()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        var entity = CreateValid{{name}}(id);
+        _mockRepository.Setup(x => x.GetByIdAsync(id, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(entity);
+        _mockUnitOfWork.Setup(x => x.SaveChangesAsync(It.IsAny<CancellationToken>()))
+            .ReturnsAsync(1);
+
+        // Act
+        await _sut.DeleteAsync(id);
+
+        // Assert
+        _mockRepository.Verify(x => x.Remove(entity), Times.Once);
+        _mockUnitOfWork.Verify(x => x.SaveChangesAsync(It.IsAny<CancellationToken>()), Times.Once);
+    }
+    {{/if}}
+
+    [Fact]
+    public async Task DeleteAsync_WhenNotExists_ShouldThrowException()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        _mockRepository.Setup(x => x.GetByIdAsync(id, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(({{name}}?)null);
+
+        // Act
+        var act = () => _sut.DeleteAsync(id);
+
+        // Assert
+        await act.Should().ThrowAsync<NotFoundException>();
+    }
+
+    #endregion
+
+    {{#unless isSystemEntity}}
+    #region Tenant Isolation Tests
+
+    [Fact]
+    public async Task CreateAsync_ShouldUseCurrentTenantId()
+    {
+        // Arrange
+        var expectedTenantId = Guid.NewGuid();
+        _mockTenantContext.Setup(x => x.TenantId).Returns(expectedTenantId);
+
+        var request = new Create{{name}}Request { Code = "TEST" };
+        {{name}}? capturedEntity = null;
+        _mockRepository.Setup(x => x.AddAsync(It.IsAny<{{name}}>(), It.IsAny<CancellationToken>()))
+            .Callback<{{name}}, CancellationToken>((e, _) => capturedEntity = e)
+            .Returns(Task.CompletedTask);
+        _mockUnitOfWork.Setup(x => x.SaveChangesAsync(It.IsAny<CancellationToken>()))
+            .ReturnsAsync(1);
+
+        // Act
+        await _sut.CreateAsync(request);
+
+        // Assert
+        capturedEntity.Should().NotBeNull();
+        capturedEntity!.TenantId.Should().Be(expectedTenantId);
+    }
+
+    [Fact]
+    public async Task GetByIdAsync_ShouldRespectTenantScope()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        var tenantId = Guid.NewGuid();
+        _mockTenantContext.Setup(x => x.TenantId).Returns(tenantId);
+
+        // Act
+        await _sut.GetByIdAsync(id);
+
+        // Assert
+        _mockRepository.Verify(
+            x => x.GetByIdAsync(id, It.IsAny<CancellationToken>()),
+            Times.Once
+        );
+        // Repository should be configured to filter by tenant
+    }
+
+    #endregion
+    {{/unless}}
+
+    #region Error Handling Tests
+
+    [Fact]
+    public async Task CreateAsync_WhenRepositoryFails_ShouldThrowException()
+    {
+        // Arrange
+        var request = new Create{{name}}Request { Code = "TEST" };
+        _mockRepository.Setup(x => x.AddAsync(It.IsAny<{{name}}>(), It.IsAny<CancellationToken>()))
+            .ThrowsAsync(new Exception("Database error"));
+
+        // Act
+        var act = () => _sut.CreateAsync(request);
+
+        // Assert
+        await act.Should().ThrowAsync<Exception>()
+            .WithMessage("*Database error*");
+    }
+
+    [Fact]
+    public async Task UpdateAsync_WhenConcurrencyConflict_ShouldThrowException()
+    {
+        // Arrange
+        var id = Guid.NewGuid();
+        var entity = CreateValid{{name}}(id);
+        var request = new Update{{name}}Request();
+
+        _mockRepository.Setup(x => x.GetByIdAsync(id, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(entity);
+        _mockUnitOfWork.Setup(x => x.SaveChangesAsync(It.IsAny<CancellationToken>()))
+            .ThrowsAsync(new DbUpdateConcurrencyException());
+
+        // Act
+        var act = () => _sut.UpdateAsync(id, request);
+
+        // Assert
+        await act.Should().ThrowAsync<ConcurrencyException>();
+    }
+
+    #endregion
+
+    #region Helper Methods
+
+    private static {{name}} CreateValid{{name}}(Guid? id = null)
+    {
+        {{#if isSystemEntity}}
+        var entity = {{name}}.Create("TEST-001", "test@example.com");
+        {{else}}
+        var entity = {{name}}.Create(Guid.NewGuid(), "TEST-001", "test@example.com");
+        {{/if}}
+
+        if (id.HasValue)
+        {
+            // Use reflection to set Id for testing
+            typeof({{name}}).GetProperty("Id")!.SetValue(entity, id.Value);
+        }
+
+        return entity;
+    }
+
+    #endregion
+}