Best Practices
& Lưu ý

// Handler nằm ở Application.dll nhưng chỉ scan WebApi.dll
builder.Services.AddMediatR(cfg =>
    cfg.RegisterServicesFromAssembly(typeof(Program).Assembly)
);
// ↑ KHÔNG tìm thấy handlers ở Application.dll!

// Fix: scan cả Application assembly
builder.Services.AddMediatR(cfg =>
    cfg.RegisterServicesFromAssemblies(
        typeof(Program).Assembly,
        typeof(CreateProductCommand).Assembly // Application.dll
    )
);

// DO
await _sender.Send(new CreateProductCommand(...));    // IRequest → Send()
await _publisher.Publish(new ProductCreatedNotification(...)); // INotification → Publish()

// DON'T
await _sender.Send(new ProductCreatedNotification(...)); // WRONG!
await _publisher.Publish(new CreateProductCommand(...));  // WRONG!

// DO: bắt exception trong notification handler
public async Task Handle(
    ProductCreatedNotification notification,
    CancellationToken ct)
{
    try
    {
        await _email.SendAsync(...);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Failed to send email for product {Id}",
            notification.ProductId);
        // KHÔNG re-throw — cho phép handlers tiếp theo chạy
    }
}

// DON'T: handler gọi Send() lồng nhau
public class CreateOrderHandler : ...
{
    private readonly ISender _sender;

    public async Task Handle(...)
    {
        // Gọi handler khác — anti-pattern!
        var product = await _sender.Send(
            new GetProductByIdQuery(request.ProductId));
        ...
    }
}

// DO: inject shared service trực tiếp
public class CreateOrderHandler : ...
{
    private readonly AppDbContext _db; // Truy cập trực tiếp

    public async Task Handle(...)
    {
        var product = await _db.Products
            .FindAsync(request.ProductId);
        ...
    }
}

public class CreateProductHandlerTests
{
    [Fact]
    public async Task Handle_ValidCommand_ReturnsProductId()
    {
        // Arrange
        var db = CreateInMemoryDbContext();
        var handler = new CreateProductHandler(db);
        var command = new CreateProductCommand(
            "Laptop", 999.99m, "Electronics");

        // Act
        var id = await handler.Handle(command, CancellationToken.None);

        // Assert
        Assert.True(id > 0);
        var product = await db.Products.FindAsync(id);
        Assert.Equal("Laptop", product!.Name);
        Assert.Equal(999.99m, product.Price);
    }

    [Fact]
    public async Task Handle_NotFound_ThrowsNotFoundException()
    {
        var db = CreateInMemoryDbContext();
        var handler = new GetProductByIdHandler(db);

        await Assert.ThrowsAsync<NotFoundException>(
            () => handler.Handle(
                new GetProductByIdQuery(999),
                CancellationToken.None));
    }
}

public class ValidationBehaviorTests
{
    [Fact]
    public async Task Handle_InvalidRequest_ThrowsValidationException()
    {
        // Arrange
        var validators = new List<IValidator<CreateProductCommand>>
        {
            new CreateProductValidator()
        };

        var behavior = new ValidationBehavior<
            CreateProductCommand, int>(validators);

        var invalidCommand = new CreateProductCommand(
            "", -1, ""); // Invalid!

        RequestHandlerDelegate<int> next =
            () => Task.FromResult(1); // Mock next

        // Act & Assert
        await Assert.ThrowsAsync<ValidationException>(
            () => behavior.Handle(
                invalidCommand, next, CancellationToken.None));
    }

    [Fact]
    public async Task Handle_NoValidators_CallsNext()
    {
        var behavior = new ValidationBehavior<
            CreateProductCommand, int>(
            Enumerable.Empty<IValidator<CreateProductCommand>>());

        var nextCalled = false;
        RequestHandlerDelegate<int> next = () =>
        {
            nextCalled = true;
            return Task.FromResult(42);
        };

        var result = await behavior.Handle(
            new CreateProductCommand("Test", 10, "Cat"),
            next, CancellationToken.None);

        Assert.True(nextCalled);
        Assert.Equal(42, result);
    }
}