AstreCode.Backend.Shared.UnitTest 8.0.0

AstreCode.Backend.Shared.UnitTest

Testing utilities and base classes for AstreCode microservices.

Description

The AstreCode.Backend.Shared.UnitTest package provides essential testing utilities and base classes for building comprehensive test suites for .NET 8.0 backend services. This package includes test service base classes, mocking utilities, and testing helpers.

Installation

To install this package, use the .NET CLI:

dotnet add package AstreCode.Backend.Shared.UnitTest

Or via Package Manager Console:

Install-Package AstreCode.Backend.Shared.UnitTest

Features

🧪 Test Service Base Classes

• ApplicationTestService: Base class for application service testing
• UnitTestService: Base class for unit testing with common utilities
• Test Data Builders: Helper classes for creating test data
• Mock Setup Utilities: Common mocking patterns and setups

🔧 Testing Utilities

• Mock Management: Centralized mock object management
• Test Data Factories: Factory patterns for test data creation
• Assertion Helpers: Custom assertion methods and extensions
• Test Configuration: Test-specific configuration helpers

📊 Mocking Framework Integration

• NSubstitute Integration: Pre-configured NSubstitute mocking
• Mock Factories: Factory methods for common mock objects
• Mock Verification: Helper methods for mock verification
• Test Doubles: Stub and mock implementations

🏗️ Test Infrastructure

• Test Base Classes: Common test infrastructure
• Setup and Teardown: Standardized test lifecycle management
• Test Isolation: Proper test isolation and cleanup
• Performance Testing: Basic performance testing utilities

Example Usage

Application Service Testing

using Shared.UnitTest;
using NSubstitute;
using Xunit;

public class UserServiceTests : ApplicationTestService
{
    private readonly IUserService _userService;
    private readonly IUserRepository _userRepository;

    public UserServiceTests()
    {
        _userRepository = Substitute.For<IUserRepository>();
        _userService = new UserService(_userRepository, Mapper, Localizer, EncryptionService, UnitOfWork, CurrentUser);
    }

    [Fact]
    public async Task CreateUserAsync_ValidData_ReturnsUserDto()
    {
        // Arrange
        var createUserDto = new CreateUserDto
        {
            FirstName = "John",
            LastName = "Doe",
            Email = "john.doe@example.com"
        };

        var user = new User
        {
            Id = Guid.NewGuid(),
            FirstName = createUserDto.FirstName,
            LastName = createUserDto.LastName,
            Email = createUserDto.Email
        };

        _userRepository.AddAsync(Arg.Any<User>()).Returns(user);

        // Act
        var result = await _userService.CreateUserAsync(createUserDto);

        // Assert
        Assert.NotNull(result);
        Assert.Equal(createUserDto.FirstName, result.FirstName);
        Assert.Equal(createUserDto.LastName, result.LastName);
        Assert.Equal(createUserDto.Email, result.Email);
        
        await _userRepository.Received(1).AddAsync(Arg.Any<User>());
    }

    [Fact]
    public async Task GetUserAsync_UserExists_ReturnsUserDto()
    {
        // Arrange
        var userId = Guid.NewGuid();
        var user = new User
        {
            Id = userId,
            FirstName = "John",
            LastName = "Doe",
            Email = "john.doe@example.com"
        };

        _userRepository.GetByIdAsync(userId).Returns(user);

        // Act
        var result = await _userService.GetUserAsync(userId);

        // Assert
        Assert.NotNull(result);
        Assert.Equal(userId, result.Id);
        Assert.Equal("John", result.FirstName);
    }

    [Fact]
    public async Task GetUserAsync_UserNotFound_ThrowsNotFoundException()
    {
        // Arrange
        var userId = Guid.NewGuid();
        _userRepository.GetByIdAsync(userId).Returns((User)null);

        // Act & Assert
        await Assert.ThrowsAsync<NotFoundException>(() => _userService.GetUserAsync(userId));
    }
}

Unit Test Service Usage

using Shared.UnitTest;
using NSubstitute;
using Xunit;

public class EmailServiceTests : UnitTestService
{
    private readonly IEmailService _emailService;

    public EmailServiceTests()
    {
        _emailService = new EmailService();
    }

    [Theory]
    [InlineData("test@example.com", true)]
    [InlineData("invalid-email", false)]
    [InlineData("", false)]
    [InlineData(null, false)]
    public void IsValidEmail_ValidatesEmailCorrectly(string email, bool expected)
    {
        // Act
        var result = _emailService.IsValidEmail(email);

        // Assert
        Assert.Equal(expected, result);
    }

    [Fact]
    public void SendEmailAsync_ValidEmail_SendsSuccessfully()
    {
        // Arrange
        var emailDto = new EmailDto
        {
            To = "test@example.com",
            Subject = "Test Subject",
            Body = "Test Body"
        };

        // Act
        var result = _emailService.SendEmailAsync(emailDto);

        // Assert
        Assert.NotNull(result);
        Assert.True(result.IsCompletedSuccessfully);
    }
}

Test Data Builders

using Shared.UnitTest;

public class UserTestDataBuilder
{
    private User _user = new User();

    public UserTestDataBuilder WithId(Guid id)
    {
        _user.Id = id;
        return this;
    }

    public UserTestDataBuilder WithName(string firstName, string lastName)
    {
        _user.FirstName = firstName;
        _user.LastName = lastName;
        return this;
    }

    public UserTestDataBuilder WithEmail(string email)
    {
        _user.Email = email;
        return this;
    }

    public UserTestDataBuilder WithStatus(UserStatus status)
    {
        _user.Status = status;
        return this;
    }

    public User Build()
    {
        return _user;
    }

    public static UserTestDataBuilder Create() => new UserTestDataBuilder();
}

// Usage in tests
[Fact]
public async Task UpdateUserAsync_ValidData_UpdatesUser()
{
    // Arrange
    var user = UserTestDataBuilder.Create()
        .WithId(Guid.NewGuid())
        .WithName("John", "Doe")
        .WithEmail("john.doe@example.com")
        .WithStatus(UserStatus.Active)
        .Build();

    var updateDto = new UpdateUserDto
    {
        FirstName = "Jane",
        LastName = "Smith"
    };

    _userRepository.GetByIdAsync(user.Id).Returns(user);

    // Act
    var result = await _userService.UpdateUserAsync(user.Id, updateDto);

    // Assert
    Assert.Equal("Jane", result.FirstName);
    Assert.Equal("Smith", result.LastName);
}

Mock Setup Utilities

using Shared.UnitTest;
using NSubstitute;

public class OrderServiceTests : ApplicationTestService
{
    private readonly IOrderService _orderService;
    private readonly IOrderRepository _orderRepository;
    private readonly IUserRepository _userRepository;

    public OrderServiceTests()
    {
        _orderRepository = Substitute.For<IOrderRepository>();
        _userRepository = Substitute.For<IUserRepository>();
        
        _orderService = new OrderService(
            _orderRepository, 
            _userRepository, 
            Mapper, 
            Localizer, 
            EncryptionService, 
            UnitOfWork, 
            CurrentUser
        );
    }

    [Fact]
    public async Task CreateOrderAsync_ValidData_CreatesOrder()
    {
        // Arrange
        var userId = Guid.NewGuid();
        var user = UserTestDataBuilder.Create()
            .WithId(userId)
            .WithStatus(UserStatus.Active)
            .Build();

        var createOrderDto = new CreateOrderDto
        {
            CustomerId = userId,
            Items = new List<OrderItemDto>
            {
                new OrderItemDto { ProductId = Guid.NewGuid(), Quantity = 2 }
            }
        };

        SetupMocks(user, createOrderDto);

        // Act
        var result = await _orderService.CreateOrderAsync(createOrderDto);

        // Assert
        Assert.NotNull(result);
        await _orderRepository.Received(1).AddAsync(Arg.Any<Order>());
        await _userRepository.Received(1).GetByIdAsync(userId);
    }

    private void SetupMocks(User user, CreateOrderDto createOrderDto)
    {
        _userRepository.GetByIdAsync(user.Id).Returns(user);
        _orderRepository.AddAsync(Arg.Any<Order>()).Returns(new Order { Id = Guid.NewGuid() });
    }
}

Performance Testing

using Shared.UnitTest;
using System.Diagnostics;

public class PerformanceTests : UnitTestService
{
    [Fact]
    public async Task ProcessLargeDataset_PerformanceTest()
    {
        // Arrange
        var largeDataset = GenerateLargeDataset(10000);
        var service = new DataProcessingService();

        // Act
        var stopwatch = Stopwatch.StartNew();
        var result = await service.ProcessDataAsync(largeDataset);
        stopwatch.Stop();

        // Assert
        Assert.NotNull(result);
        Assert.True(stopwatch.ElapsedMilliseconds < 5000, 
            $"Processing took {stopwatch.ElapsedMilliseconds}ms, expected less than 5000ms");
    }

    private List<DataItem> GenerateLargeDataset(int count)
    {
        return Enumerable.Range(1, count)
            .Select(i => new DataItem { Id = i, Value = $"Item {i}" })
            .ToList();
    }
}

Configuration

Test Project Setup

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
    <PackageReference Include="xunit" Version="2.6.1" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
    <PackageReference Include="coverlet.collector" Version="6.0.0" />
    <PackageReference Include="AstreCode.Backend.Shared.UnitTest" Version="8.0.0" />
  </ItemGroup>

</Project>

Test Configuration

// In your test setup
public class TestStartup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Configure test services
        services.AddScoped<IUserRepository, MockUserRepository>();
        services.AddScoped<IOrderRepository, MockOrderRepository>();
        
        // Configure AutoMapper for tests
        services.AddAutoMapper(typeof(TestMappingProfile));
    }
}

Dependencies

This package depends on the following NuGet packages:

• xunit.assert (2.9.2) - Unit testing assertions
• xunit.extensibility.core (2.9.0) - xUnit core functionality
• NSubstitute (5.1.0) - Mocking framework

Requirements

• .NET 8.0 or later
• xUnit testing framework
• NSubstitute mocking framework

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

This project is licensed under the MIT License - see the LICENSE.txt file for details.

Support

For support and questions, please contact the AstreCode development team.

Changelog

See CHANGELOG.md for version history and changes.

AstreCode.Backend.Shared.UnitTest - Version 8.0.0