generate-tests

Generate Tests

Generate tests for: $ARGUMENTS.target Test type: $ARGUMENTS.type Dry run: $ARGUMENTS.dry-run

Instructions

Step 1: Identify Target

If target is 'gaps':

1. Run coverage analysis (see /qa:coverage-report)
2. Identify top 5 files without tests
3. Generate tests for each

If target is file path:

1. Read the source file
2. Parse public methods and their signatures
3. Identify validators if any

If target is class name:

1. Search for the class in api/src/
2. Read the source file

Step 2: Analyze Source Code

For each public method, extract:

• Method name
• Parameters and types
• Return type
• Dependencies (injected services)
• Validation rules (if validator)
• Authorization attributes

Step 3: Generate Unit Tests

For AppServices:

using Shouldly;
using Xunit;
using NSubstitute;

namespace [Namespace].Tests;

public class [ClassName]Tests : [Module]ApplicationTestBase
{
    private readonly [ClassName] _sut;
    private readonly I[Dependency] _[dependency];

    public [ClassName]Tests()
    {
        _[dependency] = Substitute.For<I[Dependency]>();
        _sut = new [ClassName](_[dependency]);
    }

    #region [MethodName]

    [Fact]
    public async Task [MethodName]_ValidInput_ReturnsExpectedResult()
    {
        // Arrange
        var input = new [InputDto]
        {
            // Set valid properties
        };

        // Act
        var result = await _sut.[MethodName](input);

        // Assert
        result.ShouldNotBeNull();
    }

    [Fact]
    public async Task [MethodName]_InvalidInput_ThrowsValidationException()
    {
        // Arrange
        var input = new [InputDto](); // Missing required fields

        // Act & Assert
        await Should.ThrowAsync<AbpValidationException>(
            () => _sut.[MethodName](input)
        );
    }

    [Fact]
    public async Task [MethodName]_NotFound_ThrowsEntityNotFoundException()
    {
        // Arrange
        var nonExistentId = Guid.NewGuid();

        // Act & Assert
        await Should.ThrowAsync<EntityNotFoundException>(
            () => _sut.[MethodName](nonExistentId)
        );
    }

    #endregion
}