Tests with xUnit v3

using System.Globalization;
using Xunit;

public sealed record OrderLine(string Sku, int Quantity, decimal UnitPrice);

public static class OrderPricing
{
    public static decimal Subtotal(IEnumerable<OrderLine> lines) => lines.Sum(l => l.Quantity * l.UnitPrice);

    // 10 percent off from 100.00, rounded half away from zero as finance expects.
    public static decimal Discount(decimal subtotal) =>
        subtotal >= 100m ? Math.Round(subtotal * 0.10m, 2, MidpointRounding.AwayFromZero) : 0m;
}

public interface IStockClient
{
    Task<int> AvailableAsync(string sku, CancellationToken ct);
}

public sealed class StockCheck(IStockClient stock)
{
    public async Task<bool> CanFulfilAsync(IReadOnlyList<OrderLine> lines, CancellationToken ct)
    {
        foreach (var line in lines)
        {
            if (await stock.AvailableAsync(line.Sku, ct) < line.Quantity) return false;
        }
        return true;
    }
}

public sealed class OrderPricingTests
{
    [Fact]
    public void Subtotal_of_an_empty_order_is_zero() => Assert.Equal(0m, OrderPricing.Subtotal([]));

    [Theory]
    [InlineData("99.99", "0")]
    [InlineData("100.00", "10.00")]
    [InlineData("100.05", "10.01")] // 10.005 rounds up here; banker's rounding would give 10.00
    public void Discount_starts_at_one_hundred(string subtotal, string expected)
    {
        var actual = OrderPricing.Discount(decimal.Parse(subtotal, CultureInfo.InvariantCulture));

        Assert.Equal(decimal.Parse(expected, CultureInfo.InvariantCulture), actual);
    }

    public static TheoryData<OrderLine[], decimal> Orders => new()
    {
        { [new("KETTLE-BLUE", 2, 34.50m)], 69.00m },
        { [new("KETTLE-BLUE", 1, 34.50m), new("MUG-WHITE", 4, 7.25m)], 63.50m },
    };

    [Theory]
    [MemberData(nameof(Orders))]
    public void Subtotal_adds_every_line(OrderLine[] lines, decimal expected) =>
        Assert.Equal(expected, OrderPricing.Subtotal(lines));
}

public sealed class StockCheckTests
{
    private sealed class FixedStock(int available) : IStockClient
    {
        public Task<int> AvailableAsync(string sku, CancellationToken ct)
        {
            ct.ThrowIfCancellationRequested();
            return Task.FromResult(available);
        }
    }

    [Fact(Timeout = 5_000)]
    public async Task Order_larger_than_stock_cannot_be_fulfilled()
    {
        var check = new StockCheck(new FixedStock(available: 3));

        var canFulfil = await check.CanFulfilAsync(
            [new OrderLine("MUG-WHITE", 4, 7.25m)], TestContext.Current.CancellationToken);

        Assert.False(canFulfil);
    }
}