Tester son code

dotnet new xunit -o Boutique.Tests          # xUnit v3 depuis .NET 10
cd Boutique.Tests
dotnet add reference ../Boutique.Domaine/Boutique.Domaine.csproj
dotnet test

public class CalculTarifTests
{
    [Fact]                                     // un cas unique
    public void Enfant_de_moins_de_4_ans_gratuit()
    {
        // Arrange — préparer
        var calcul = new CalculTarif();
        var passager = new Passager(Age: 3);

        // Act — agir (UNE seule action)
        var tarif = calcul.Calculer(passager);

        // Assert — vérifier
        Assert.Equal(0m, tarif);
    }

    [Theory]                                   // plusieurs cas, un seul code
    [InlineData(3, 0)]
    [InlineData(12, 5)]
    [InlineData(30, 12)]
    [InlineData(70, 8)]
    public void Tarif_selon_age(int age, decimal attendu)
        => Assert.Equal(attendu, new CalculTarif().Calculer(new Passager(age)));

    [Fact]
    public void Age_negatif_rejete()
    {
        var ex = Assert.Throws<ArgumentOutOfRangeException>(
            () => new CalculTarif().Calculer(new Passager(-1)));
        Assert.Contains("Age", ex.Message);
    }
}

// dotnet add package Microsoft.AspNetCore.Mvc.Testing
public class ProduitsApiTests(WebApplicationFactory<Program> usine)
    : IClassFixture<WebApplicationFactory<Program>>
{
    [Fact]
    public async Task Get_produits_renvoie_200_et_du_json()
    {
        var client = usine.CreateClient();

        var reponse = await client.GetAsync("/produits");

        reponse.EnsureSuccessStatusCode();
        Assert.Equal("application/json", reponse.Content.Headers.ContentType?.MediaType);
        var produits = await reponse.Content.ReadFromJsonAsync<List<ProduitDto>>();
        Assert.NotNull(produits);
    }

    [Fact]
    public async Task Post_produit_invalide_renvoie_400_avec_details()
    {
        var client = usine.CreateClient();

        var reponse = await client.PostAsJsonAsync("/produits", new { Nom = "", Prix = -5 });

        Assert.Equal(HttpStatusCode.BadRequest, reponse.StatusCode);
        var probleme = await reponse.Content.ReadFromJsonAsync<ValidationProblemDetails>();
        Assert.Contains("Nom", probleme!.Errors.Keys);
    }

    [Fact]
    public async Task Endpoint_admin_sans_droit_renvoie_403()
    {
        var client = usine.CreateClient();
        // … s'authentifier avec un utilisateur non admin …
        Assert.Equal(HttpStatusCode.Forbidden,
            (await client.DeleteAsync("/produits/1")).StatusCode);
    }
}

// dotnet add package Testcontainers.MsSql  (ou .PostgreSql)
public class UsineTest : WebApplicationFactory<Program>, IAsyncLifetime
{
    private readonly MsSqlContainer _sql = new MsSqlBuilder().Build();

    public async Task InitializeAsync()
    {
        await _sql.StartAsync();                     // démarre SQL Server en conteneur
        using var portee = Services.CreateScope();
        var db = portee.ServiceProvider.GetRequiredService<AppDb>();
        await db.Database.MigrateAsync();            // applique les VRAIES migrations
        await Semer(db);
    }

    protected override void ConfigureWebHost(IWebHostBuilder builder) =>
        builder.ConfigureServices(services =>
        {
            services.RemoveAll<DbContextOptions<AppDb>>();
            services.AddDbContext<AppDb>(o => o.UseSqlServer(_sql.GetConnectionString()));
            services.RemoveAll<IEnvoyeurEmail>();
            services.AddScoped<IEnvoyeurEmail, EnvoyeurEspion>();   // pas de vrai email
        });

    public new async Task DisposeAsync() => await _sql.DisposeAsync();
}

// dotnet add package bunit
public class CompteurTests : TestContext
{
    [Fact]
    public void Le_clic_incremente_et_previent_le_parent()
    {
        var recu = 0;
        var composant = RenderComponent<Compteur>(p => p
            .Add(c => c.Titre, "Essai")
            .Add(c => c.OnChangement, v => recu = v));

        composant.Find("button").Click();

        Assert.Contains("Valeur actuelle : <b>1</b>", composant.Markup);
        Assert.Equal(1, recu);
    }

    [Fact]
    public void Le_bouton_est_desactive_au_maximum()
    {
        var c = RenderComponent<Compteur>(p => p.Add(x => x.Maximum, 1));
        c.Find("button").Click();
        Assert.True(c.Find("button").HasAttribute("disabled"));
    }
}

dotnet test                                     # tout
dotnet test --filter "FullyQualifiedName~Tarif" # par nom
dotnet test --filter "Category=Integration"     # par trait
dotnet test --no-dependencies                   # .NET 11 : sans reconstruire les dépendances
dotnet test --collect:"XPlat Code Coverage"     # couverture (format Cobertura)
dotnet watch test                               # relance à chaque modification