测试体系：xUnit 与 Moq

// xUnit 测试类
public class OrderCalculatorTests
{
    private readonly OrderCalculator _calc = new();

    [Fact]
    public void CalculateTotal_WithTwoLines_ReturnsSum()
    {
        var order = new Order
        {
            Lines = [ new(10m), new(20m) ]
        };

        var total = _calc.CalculateTotal(order);

        Assert.Equal(30m, total);
    }

    [Theory]
    [InlineData(100, 0, 100)]
    [InlineData(100, 0.1, 90)]
    [InlineData(100, 0.5, 50)]
    public void ApplyDiscount_WithRate_ReturnsExpected(decimal price,
        decimal discount, decimal expected)
    {
        Assert.Equal(expected, _calc.ApplyDiscount(price, discount));
    }
}

// NUnit 等价写法
[TestFixture]
public class OrderCalculatorTests
{
    private OrderCalculator _calc;

    [SetUp]
    public void Setup() => _calc = new OrderCalculator();

    [Test]
    public void CalculateTotal_WithTwoLines_ReturnsSum() { ... }

    [TestCase(100, 0, 100)]
    [TestCase(100, 0.1, 90)]
    public void ApplyDiscount_WithRate_ReturnsExpected(
        decimal price, decimal discount, decimal expected) { ... }
}

public class OrderServiceTests
{
    private readonly OrderService _service;
    private readonly Mock<IOrderRepository> _repo = new();

    public OrderServiceTests()
    {
        _service = new OrderService(_repo.Object);
    }

    [Fact]
    public async Task GetById_OrderExists_ReturnsOrder()
    {
        // Arrange
        var order = new Order { Id = 42, Total = 100m };
        _repo.Setup(r => r.FindAsync(42))
             .ReturnsAsync(order);

        // Act
        var result = await _service.GetByIdAsync(42);

        // Assert
        Assert.NotNull(result);
        Assert.Equal(42, result.Id);
        _repo.Verify(r => r.FindAsync(42), Times.Once);
    }

    [Fact]
    public async Task GetById_OrderMissing_ReturnsNull()
    {
        _repo.Setup(r => r.FindAsync(It.IsAny<int>()))
             .ReturnsAsync((Order?)null);

        var result = await _service.GetByIdAsync(999);

        Assert.Null(result);
    }
}

public interface IOrderRepository
{
    Task<Order?> FindAsync(int id);
    Task SaveAsync(Order order);
}

public class OrderService(IOrderRepository repo, IPaymentClient payments)
{
    public async Task<Order> CheckoutAsync(int id)
    {
        var order = await repo.FindAsync(id)
            ?? throw new KeyNotFoundException($"订单 {id} 不存在");

        await payments.ChargeAsync(order.CustomerId, order.Total);
        order.MarkPaid();
        await repo.SaveAsync(order);
        return order;
    }
}

// Moq 行为与验证
[Fact]
public async Task Checkout_PaymentSucceeds_MarksOrderPaid()
{
    var order = new Order { Id = 1, CustomerId = 9, Total = 50m };
    var repo = new Mock<IOrderRepository>();
    repo.Setup(r => r.FindAsync(1)).ReturnsAsync(order);

    var payments = new Mock<IPaymentClient>();
    payments.Setup(p => p.ChargeAsync(9, 50m)).Returns(Task.CompletedTask);

    var svc = new OrderService(repo.Object, payments.Object);
    var result = await svc.CheckoutAsync(1);

    Assert.True(result.IsPaid);
    payments.Verify(p => p.ChargeAsync(9, 50m), Times.Once);
    repo.Verify(r => r.SaveAsync(order), Times.Once);
}

[Fact]
public async Task FetchAll_RunsConcurrently_AllComplete()
{
    var client = new Mock<IHttpClient>();
    // 每次调用返回受控的 Task
    client.Setup(c => c.GetAsync(It.IsAny<string>()))
          .Returns<string>(u => Task.FromResult($"data-{u}"));

    var fetcher = new ConcurrentFetcher(client.Object);

    var results = await fetcher.FetchAllAsync(["a", "b", "c"]);

    Assert.Equal(3, results.Count);
    client.Verify(c => c.GetAsync("a"), Times.Once);
}

[Fact]
public async Task Run_Cancelled_ThrowsOperationCanceled()
{
    using var cts = new CancellationTokenSource();
    cts.Cancel();   // 预先取消

    var worker = new Worker();

    await Assert.ThrowsAsync<OperationCanceledException>(() =>
        worker.RunAsync(cts.Token));
}

public class ShopApiFactory : WebApplicationFactory<Program>
{
    protected override void ConfigureWebHost(IWebHostBuilder builder)
    {
        // 覆盖配置：测试库连接串
        builder.UseSetting("ConnectionStrings:Default",
            "Server=localhost;Database=shop_test;...");

        // 替换外部服务
        builder.ConfigureServices(services =>
        {
            services.RemoveAll<IPaymentClient>();
            services.AddSingleton<IPaymentClient, FakePaymentClient>();
        });
    }
}

public class OrdersApiTests : IClassFixture<ShopApiFactory>
{
    private readonly HttpClient _client;

    public OrdersApiTests(ShopApiFactory factory)
    {
        _client = factory.CreateClient();
    }

    [Fact]
    public async Task GetOrder_Existing_Returns200AndBody()
    {
        var response = await _client.GetAsync("/api/orders/1");

        response.EnsureSuccessStatusCode();
        var order = await response.Content.ReadFromJsonAsync<OrderDto>();
        Assert.NotNull(order);
        Assert.Equal(1, order.Id);
    }

    [Fact]
    public async Task CreateOrder_Invalid_Returns400()
    {
        var payload = new { CustomerName = "" };   // 触发验证失败
        var response = await _client.PostAsJsonAsync("/api/orders", payload);

        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
    }
}

// Fake：内存版消息队列，真实行为
public class InMemoryMessageBus : IMessageBus
{
    private readonly Channel<Message> _channel = Channel.CreateUnbounded<Message>();

    public async ValueTask PublishAsync(Message msg) =>
        await _channel.Writer.WriteAsync(msg);

    public async ValueTask<Message?> ConsumeAsync(CancellationToken ct) =>
        await _channel.Reader.ReadAsync(ct);
}

// 测试里直接使用
var bus = new InMemoryMessageBus();
await bus.PublishAsync(new("order.created", id: 1));
var msg = await bus.ConsumeAsync(ct);
Assert.Equal(1, msg.Id);

# 安装收集器
dotnet add package coverlet.collector

# 收集覆盖率（输出到 TestResults/）
dotnet test --collect:"XPlat Code Coverage"

# 生成可读报告
dotnet tool install -g dotnet-reportgenerator-globaltool
reportgenerator -reports:"TestResults/**/coverage.cobertura.xml" \
  -targetdir:"coveragereport" -reporttypes:Html

# GitHub Actions 片段
- name: Run tests with coverage
  run: dotnet test --collect:"XPlat Code Coverage" /p:Threshold=80
- name: Upload coverage artifact
  uses: actions/upload-artifact@v4
  with:
    name: coverage
    path: coveragereport