klod68/gen-test-class

---

name: gen-test-class description: "Use when creating a test class for a source file or when no tests exist yet for a class. Generates a convention-compliant xUnit test class covering all six coverage categories (happy path, validation, not-found, cancellation, invariants, round-trip). Pairs with gen-gherkin-feature (upstream criteria) and gen-use-case (upstream model). Also invoke when the user mentions: write tests, add unit tests, test class, xUnit tests for, test coverage. Domain: Testing, Code Generation. Level: Intermediate."

Generate a complete test class for the source file I am currently pointing at.

What to generate

Produce tests for all six coverage categories — do not omit any:

1. Constructor preconditions — null, empty, and whitespace arguments; out-of-range values
2. Default values — property state after a valid default construction
3. Guard clauses — every argument validation in every public method
4. Happy path — normal execution with valid, representative inputs
5. Edge cases — empty collections, boundary values, nullable optionals
6. Error contract — exceptions that must be thrown and (if applicable) re-thrown after recording

---

File placement

• Mirror the source path: ${1:SourceProject}/X.cs → ${2:TestProject}/XTests.cs
• Namespace: file-scoped, matching the mirrored path
• Class name: {SourceClass}Tests

---

Class skeleton

namespace ${3:RootNamespace}.Tests.{SubNamespace};

/// <summary>Tests for {SourceClass}.</summary>
public class {SourceClass}Tests
{
    #region Test Implementation   // expose protected members if needed
    #endregion

    #region Constructor Tests
    #endregion

    #region Default Values Tests
    #endregion

    #region {MethodGroup} Tests   // one region per public method group
    #endregion

    #region Helper Methods        // reusable mock setup and factory methods
    #endregion
}

---

Naming convention

{Method}_{Scenario}_{ExpectedBehavior}

Examples:

• Constructor_NullLogger_ThrowsArgumentNullException
• GetById_ValidId_ReturnsExpectedEntity
• FindAll_EmptyRepository_ReturnsEmptyCollection
• Save_CancellationRequested_PropagatesToken

---

Framework — xUnit + FluentAssertions + Moq

// Single case
[Fact]
public void Method_Scenario_ExpectedBehavior() { }

// Parameterized
[Theory]
[InlineData(null)]
[InlineData("")]
[InlineData("   ")]
public void Method_InvalidInput_Throws(string? input) { }

// Exception assertion
var act = () => new MyClass(null!);
act.Should().Throw<ArgumentNullException>().WithParameterName("paramName");

// Async exception
var act = async () => await sut.DoAsync(null!, ct);
await act.Should().ThrowAsync<ArgumentNullException>();

// Happy path
result.Should().NotBeNull();
result.Should().Be(expected);
collection.Should().HaveCount(3).And.Contain(x => x.Id == expectedId);

---

Mocking rules

• Mock only external dependencies (repositories, HTTP clients, loggers, clocks).
• Never mock types defined in this solution — test through the real implementation.
• Use static helper methods (CreateMockLogger(), CreateSut()) to avoid setup duplication.
• CancellationToken propagation: verify the mock received the same token the caller passed.

---

Arrange-Act-Assert

Always use explicit section comments:

[Fact]
public async Task SaveAsync_ValidEntity_PersistsAndReturnsVoid()
{
    // Arrange
    var entity = new OrderBuilder().WithDefaults().Build();
    _repositoryMock.Setup(r => r.SaveAsync(entity, It.IsAny<CancellationToken>()))
                   .Returns(Task.CompletedTask);

    // Act
    await _sut.SaveAsync(entity, CancellationToken.None);

    // Assert
    _repositoryMock.Verify(r => r.SaveAsync(entity, It.IsAny<CancellationToken>()), Times.Once);
}

---

Constraints

• Follow all rules in the workspace root instruction file.
• One logical assertion per test (FluentAssertions chains count as one).
• No if, for, or switch inside test methods — use [Theory] instead.
• No shared mutable state between tests.
• Test class must be self-contained — each test sets up its own state.

---

Mock Boundary Rule

| Mock (external dependency) | Use Real (internal type) | |---|---| | IDbConnection, IDbCommand | Domain entities, value objects | | HttpClient, IHttpClientFactory | Mappers, formatters, validators | | ILogger<T> | Configuration classes | | IFileSystem (abstraction) | DTOs, records, enums |

• Never mock types from external NuGet packages directly — wrap behind your own interface first.
• Mock at the boundary of your code, not at the boundary of the framework.
• Use a helper method (CreateSut()) to centralize mock setup and avoid duplication.

Testing Abstract Types

For abstract base classes, create a private test subclass inside the test class:

public class DataProviderBaseTests
{
    private sealed class TestProvider : DataProviderBase
    {
        public TestProvider(string connectionString)
            : base(connectionString) { }

        // Minimal implementation of abstract members
        public override Task<T?> GetByIdAsync<T>(int id, CancellationToken ct) where T : default
            => Task.FromResult(default(T));
    }

    [Fact]
    public void Constructor_NullConnection_ThrowsArgumentException()
    {
        var act = () => new TestProvider(null!);
        act.Should().Throw<ArgumentException>();
    }
}

• Test subclass is private sealed inside the test class — never shared.
• Implement abstract members with minimal stubs — the test focuses on base class behavior.
• Use InternalsVisibleTo in the library .csproj to test internal abstract types.

After generating

Run to verify compilation and execution:

dotnet test ${4:Solution.sln} --filter "FullyQualifiedName~{SourceClass}Tests"