Un Talos européen de qualité - Part X - Dev et Tests d'intégration

part-10

Objectif 🎯

Dans cette partie de la série, nous allons faire un interlude dédié au développement d’un exemple d’application en WebApi ASP.NET simple, dont l’objectif sera son intégration complète à notre toute nouvelle infrastructure flambant neuve, incluant tests d’intégration sur une réelle base de données PostgreSQL, qualité / métriques de code et couverture de tests.

Initialisation

Créer un répertoire projet vide nommé conduit puis utiliser Mise pour installer la dernière version du sdk dotnet via la commande mise use dotnet@10. Enfin, initialisez le projet comme suit :

dotnet new webapi -o Conduit.WebApi
dotnet new gitignore
dotnet new editorconfig
dotnet new sln
dotnet sln add Conduit.WebApi
dotnet new classlib -o Conduit.Business
dotnet sln add Conduit.Business
dotnet add Conduit.WebApi reference Conduit.Business

Créer le repo Git ohmytalos/conduit (ohmytalos en tant qu’organisation ici, mais rien n’empêche d’utiliser votre propre compte) sur votre nouvelle instance Gitea bien fraîche et poussez-y votre code :

g init
gaa
gcmsg "init"
git remote add origin git@ssh.ohmytalos.io:ohmytalos/conduit.git
git push -u origin main

Note (Remarque)

On utilise SSH pour le push de code sur Gitea, assurez-vous donc d’avoir ajouté vos clés SSH publiques à votre compte Gitea.

Entités et EF Core

Créez 2 entités :

User
Article

1
using System.ComponentModel.DataAnnotations;
2

3
namespace Conduit.Business.Models;
4

5
public class User
6
{
7
    private readonly List<Article> _articles = [];
8

9
    public int Id { get; set; }
10

11
    [MaxLength(255)]
12
    public required string Name { get; set; }
13

14
    [MaxLength(255)]
15
    public required string Email { get; set; }
16

17
    public string? Bio { get; set; }
18

19
    [MaxLength(255)]
20
    public string? Image { get; set; }
21

22
    public DateTime CreatedAt { get; set; }
23

24
    public DateTime UpdatedAt { get; set; }
25

26
    public virtual IReadOnlyCollection<Article> Articles => _articles;
27
}

1
using System.ComponentModel.DataAnnotations;
2

3
using Microsoft.EntityFrameworkCore;
4

5
namespace Conduit.Business.Models;
6

7
[Index("Slug", IsUnique = true)]
8
public class Article
9
{
10
    public int Id { get; set; }
11

12
    public int AuthorId { get; set; }
13

14
    public required virtual User Author { get; set; }
15

16

17
    [MaxLength(255)]
18
    public required string Title { get; set; }
19

20

21
    [MaxLength(255)]
22
    public required string Slug { get; set; }
23

24
    public required string Description { get; set; }
25

26
    public required string Body { get; set; }
27

28
    public DateTime CreatedAt { get; set; }
29

30
    public DateTime UpdatedAt { get; set; }
31
}

Installer les dépendances ORM :

dotnet add Conduit.Business package Microsoft.Extensions.Configuration.Abstractions
dotnet add Conduit.Business package Microsoft.Extensions.DependencyInjection.Abstractions
dotnet add Conduit.Business package Microsoft.EntityFrameworkCore
dotnet add Conduit.Business package Npgsql.EntityFrameworkCore.PostgreSQL
dotnet add Conduit.Business package Microsoft.EntityFrameworkCore.Proxies

dotnet add Conduit.WebApi package Microsoft.EntityFrameworkCore.Design

1
using Conduit.Business.Models;
2

3
using Microsoft.EntityFrameworkCore;
4

5
namespace Conduit.Business.Contexts;
6

7
public class AppDbContext(DbContextOptions<AppDbContext> options) : DbContext(options)
8
{
9
    public DbSet<User> Users => Set<User>();
10
    public DbSet<Article> Articles => Set<Article>();
11
}

1
using Conduit.Business.Contexts;
2
using Microsoft.EntityFrameworkCore;
3
using Microsoft.Extensions.Configuration;
4
using Microsoft.Extensions.DependencyInjection;
5

6
namespace Conduit.Business.Extensions;
7

8
public static class BusinessServicesExtensions
9
{
10
    public static IServiceCollection AddBusinessServices(this IServiceCollection services, IConfiguration configuration)
11
    {
12
        return services
13
            .AddDbContext<AppDbContext>(options =>
14
                options
15
                    .UseLazyLoadingProxies()
16
                    .UseNpgsql(
17
                        configuration.GetConnectionString("DefaultConnection")
18
                    )
19
            );
20
    }
21
}

1
{
2
  "ConnectionStrings": {
3
    "DefaultConnection": "Host=localhost;Port=5432;Database=conduit;Username=conduit;Password=conduit"
4
  }
5
}

Installer les outils de migration DB et de qualité de code :

dotnet new tool-manifest
dotnet tool install dotnet-ef
dotnet tool install dotnet-sonarscanner
dotnet tool install coverlet.console

Lancer un postgres local :

1
services:
2
  db:
3
    image: postgres:18
4
    environment:
5
      POSTGRES_USER: conduit
6
      POSTGRES_PASSWORD: conduit
7
      POSTGRES_DB: conduit
8
    ports:
9
      - "5432:5432"
10
    volumes:
11
      - pgdata:/var/lib/postgresql/data
12

13
volumes:
14
  pgdata:

docker compose up -d

À ce stade, nous pouvons générer les fichiers de migration et les appliquer. Nous utiliserons les tasks intégrées dans mise pour centraliser les commandes récurrentes.

1
[tools]
2
dotnet = "10"
3

4
[tasks.dev]
5
run = "dotnet run --project Conduit.WebApi"
6

7
[tasks.migrations-add]
8
usage = '''
9
arg "<name>" help="Name of migration"
10
'''
11
run = '''
12
dotnet ef migrations add ${usage_name?} --project Conduit.Business --startup-project Conduit.WebApi
13
'''
14

15
[tasks.migrations-remove]
16
run = "dotnet ef migrations remove --project Conduit.Business --startup-project Conduit.WebApi"
17

18
[tasks.db-update]
19
run = "dotnet ef database update --project Conduit.Business --startup-project Conduit.WebApi"

mise migrations-add InitialCreate
mise db-update

Les tables Articles et Users sont maintenant créées dans la base de données, avec la clé étrangère qui va bien.

Prévoyez dès maintenant d’exclure les fichiers générés par EF Core de l’analyse de code :

1
#...
2

3
[**/Migrations/*.cs]
4
generated_code = true

On en profite pour inscrire les bonnes pratiques en rajoutant un fichier Directory.Build.props à la racine du repo pour configurer les paramètres globaux à tous les projets, incluant l’enrichissement de l’analyseur de code Roslyn .NET existant avec SonarAnalyzer, le traitement des warnings en erreurs, le verrouillage des versions de packages NuGet :

1
<Project>
2
    <PropertyGroup>
3
        <AnalysisLevel>latest-Recommended</AnalysisLevel>
4
        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
5
        <CodeAnalysisTreatWarningsAsErrors>true</CodeAnalysisTreatWarningsAsErrors>
6
        <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
7
    </PropertyGroup>
8
    <ItemGroup>
9
        <PackageReference
10
            Include="SonarAnalyzer.CSharp"
11
            Version="10.15.0.120848"
12
            PrivateAssets="all"
13
            Condition="$(MSBuildProjectExtension) == '.csproj'"
14
        />
15
    </ItemGroup>
16
    <ItemGroup>
17
        <SonarQubeSetting Include="sonar.exclusions">
18
            <Value>**/Migrations/*.cs</Value>
19
        </SonarQubeSetting>
20
        <SonarQubeSetting Include="sonar.coverage.exclusions">
21
            <Value>**/Migrations/*.cs</Value>
22
        </SonarQubeSetting>
23
    </ItemGroup>
24
</Project>

Minimal API

Installer les dépendances (explorateur OpenAPI et validations DTOs) :

dotnet add Conduit.WebApi package Scalar.AspNetCore
dotnet add Conduit.WebApi package FluentValidation
dotnet add Conduit.WebApi package FluentValidation.DependencyInjectionExtensions

Créez les DTOs :

1
using System.ComponentModel.DataAnnotations;
2

3
using Conduit.Business.Models;
4

5
namespace Conduit.WebApi.Dtos;
6

7
public class AuthorDto
8
{
9
    public required string Name { get; set; }
10

11
    public required string Email { get; set; }
12

13
    public string? Bio { get; set; }
14

15
    public string? Image { get; set; }
16
}
17

18
public static class AuthorDtoExtensions
19
{
20
    public static AuthorDto ToDto(this User author)
21
    {
22
        return new AuthorDto
23
        {
24
            Name = author.Name,
25
            Email = author.Email,
26
            Bio = author.Bio,
27
            Image = author.Image
28
        };
29
    }
30
}

1
using Conduit.Business.Models;
2

3
namespace Conduit.WebApi.Dtos;
4

5
public class ArticleDto
6
{
7
    public required string Title { get; set; }
8

9
    public required string Slug { get; set; }
10

11
    public required string Description { get; set; }
12

13
    public required string Body { get; set; }
14

15
    public DateTime CreatedAt { get; set; }
16

17
    public DateTime UpdatedAt { get; set; }
18

19
    public required AuthorDto Author { get; set; }
20
}
21

22
public static class ArticleDtoExtensions
23
{
24
    public static ArticleDto ToDto(this Article article)
25
    {
26
        return new ArticleDto
27
        {
28
            Title = article.Title,
29
            Slug = article.Slug,
30
            Description = article.Description,
31
            Body = article.Body,
32
            CreatedAt = article.CreatedAt,
33
            UpdatedAt = article.UpdatedAt,
34
            Author = article.Author.ToDto()
35
        };
36
    }
37
}

1
using Conduit.Business.Models;
2

3
namespace Conduit.WebApi.Dtos;
4

5
public class ArticlesDto
6
{
7
    public required List<ArticleDto> Items { get; set; }
8
    public required int Total { get; set; }
9
}

1
using Conduit.Business.Contexts;
2
using Conduit.Business.Models;
3

4
using FluentValidation;
5

6
using Microsoft.EntityFrameworkCore;
7

8
namespace Conduit.WebApi.Dtos;
9

10
public class NewArticleDto
11
{
12
    public required string Title { get; set; }
13

14
    public required string Description { get; set; }
15

16
    public required string Body { get; set; }
17

18
    public required string Author { get; set; }
19
}
20

21
public class NewArticleValidator : AbstractValidator<NewArticleDto>
22
{
23
    public NewArticleValidator(AppDbContext context)
24
    {
25
        RuleFor(x => x.Title)
26
          .NotEmpty()
27
          .MaximumLength(100);
28

29
        RuleFor(x => x.Description)
30
          .NotEmpty()
31
          .MaximumLength(250);
32

33
        RuleFor(x => x.Body)
34
          .NotEmpty();
35

36
        RuleFor(x => x.Author)
37
          .NotEmpty();
38

39
        RuleFor(x => x.Title).MustAsync(
40
            async (title, cancellationToken) => !await context.Articles
41
                .Where(x => x.Slug == title.ToSlug())
42
                .AnyAsync(cancellationToken)
43
        )
44
            .WithMessage("Slug with this title already used");
45

46
        RuleFor(x => x.Author).MustAsync(
47
            async (authorName, cancellationToken) => await context.Users
48
                .Where(u => u.Name == authorName)
49
                .AnyAsync(cancellationToken)
50
        )
51
            .WithMessage("Author not found");
52
    }
53
}
54

55
public static class NewArticleDtoExtensions
56
{
57
    public static Article ToModel(this NewArticleDto article, User author)
58
    {
59
        return new Article
60
        {
61
            Title = article.Title,
62
            Slug = article.Title.ToSlug(),
63
            Description = article.Description,
64
            Body = article.Body,
65
            CreatedAt = DateTime.UtcNow,
66
            UpdatedAt = DateTime.UtcNow,
67
            Author = author
68
        };
69
    }
70

71
    public static string ToSlug(this string title)
72
    {
73
        return title
74
            .ToLowerInvariant()
75
            .Replace(" ", "-")
76
            .Replace(".", "")
77
            .Replace(",", "")
78
            .Replace("!", "")
79
            .Replace("?", "");
80
    }
81
}

Un petit ensemble d’endpoints minimal API, avec récupération d’articles paginés, vue détail et création d’article avec validation :

1
using Conduit.Business.Contexts;
2
using Conduit.WebApi.Dtos;
3

4
using FluentValidation;
5

6
using Microsoft.AspNetCore.Mvc;
7
using Microsoft.EntityFrameworkCore;
8

9
namespace Conduit.WebApi.Endpoints;
10

11
public static class ArticlesEndpoints
12
{
13
    public static void MapArticlesEndpoints(this WebApplication app)
14
    {
15
        app.MapGet("/articles", async (AppDbContext dbContext, int offset = 0, int limit = 20) =>
16
        {
17
            var articles = await dbContext.Articles
18
                .Skip(offset)
19
                .Take(Math.Min(limit, 100))
20
                .Include(a => a.Author)
21
                .ToListAsync();
22

23
            var total = await dbContext.Articles.CountAsync();
24

25
            return Results.Ok(new ArticlesDto
26
            {
27
                Items = [.. articles.Select(a => a.ToDto())],
28
                Total = total
29
            });
30
        })
31
        .Produces<ArticlesDto>(StatusCodes.Status200OK);
32

33
        app.MapGet("/articles/{slug}", async (AppDbContext dbContext, string slug) =>
34
        {
35
            var article = await dbContext.Articles
36
                .FirstOrDefaultAsync(a => a.Slug == slug);
37

38
            return article is null
39
                ? Results.NotFound()
40
                : Results.Ok(article.ToDto());
41
        })
42
        .Produces<NotFoundResult>(StatusCodes.Status404NotFound)
43
        .Produces<ArticleDto>(StatusCodes.Status200OK);
44

45
        app.MapPost("/articles", async (AppDbContext dbContext, NewArticleDto articleDto, IValidator<NewArticleDto> validator) =>
46
        {
47
            var validationResult = await validator.ValidateAsync(articleDto);
48
            if (!validationResult.IsValid)
49
            {
50
                return Results.ValidationProblem(validationResult.ToDictionary());
51
            }
52

53
            var author = await dbContext.Users
54
                .FirstOrDefaultAsync(u => u.Name == articleDto.Author);
55

56
            if (author is null)
57
            {
58
                return Results.NotFound();
59
            }
60

61
            var article = articleDto.ToModel(author);
62
            dbContext.Articles.Add(article);
63

64
            await dbContext.SaveChangesAsync();
65

66
            return Results.Created($"/articles/{article.Slug}", article.ToDto());
67
        })
68
        .Produces<ValidationProblemDetails>(StatusCodes.Status400BadRequest)
69
        .Produces<NotFoundResult>(StatusCodes.Status404NotFound)
70
        .Produces<ArticleDto>(StatusCodes.Status201Created);
71
    }
72
}

Puis le point d’entrée du programme :

1
using System.Reflection;
2

3
using Conduit.Business.Extensions;
4
using Conduit.WebApi.Endpoints;
5

6
using FluentValidation;
7

8
using Scalar.AspNetCore;
9

10
var builder = WebApplication.CreateBuilder(args);
11

12
builder.Services
13
    .AddBusinessServices(builder.Configuration)
14
    .AddOpenApi()
15
    .AddValidatorsFromAssembly(Assembly.GetExecutingAssembly());
16

17
var app = builder.Build();
18

19
app.MapOpenApi();
20

21
app.MapScalarApiReference();
22

23
app.UseHttpsRedirection();
24

25
app.MapArticlesEndpoints();
26

27
await app.RunAsync();
28

29
public partial class Program
30
{
31
    protected Program() { }
32
}

Lancer mise dev devrait fonctionner, et aller sur /articles, il devrait retourner une liste vide.

Seed de données

On va maintenant se créer une petite application console pour seed les données.

dotnet new console -o Conduit.Console
dotnet sln add Conduit.Console

dotnet add Conduit.Console reference Conduit.Business

dotnet add Conduit.Console package Microsoft.Extensions.Hosting
dotnet add Conduit.Console package Bogus
dotnet add Conduit.Console package Respawn

1
{
2
  "ConnectionStrings": {
3
    "DefaultConnection": "Host=localhost;Port=5432;Database=conduit;Username=conduit;Password=conduit"
4
  }
5
}

1
using Bogus;
2

3
using Conduit.Business.Contexts;
4
using Conduit.Business.Models;
5

6
using Microsoft.EntityFrameworkCore;
7

8
using Npgsql;
9

10
using Respawn;
11

12
namespace Conduit.Console.Commands;
13

14
public class SeederCommand(
15
    AppDbContext dbContext
16
)
17
{
18
    public async Task SeedAsync()
19
    {
20
        await RefreshDatabase();
21

22
        var users = new Faker<User>()
23
            .RuleFor(u => u.Name, f => f.Internet.UserName())
24
            .RuleFor(u => u.Email, (f, u) => f.Internet.Email(u.Name))
25
            .RuleFor(u => u.Bio, f => f.Lorem.Sentence())
26
            .RuleFor(u => u.Image, f => f.Internet.Avatar())
27
            .Generate(50);
28

29
        dbContext.Users.AddRange(users);
30

31
        await dbContext.SaveChangesAsync();
32

33
        dbContext.Articles.AddRange(
34
            new Faker<Article>()
35
                .RuleFor(a => a.Title, f => f.Lorem.Sentence())
36
                .RuleFor(a => a.Description, f => f.Lorem.Sentences(2))
37
                .RuleFor(a => a.Body, f => f.Lorem.Paragraphs(3))
38
                .RuleFor(a => a.CreatedAt, f => f.Date.Past().ToUniversalTime())
39
                .RuleFor(a => a.UpdatedAt, (f, a) => a.CreatedAt)
40
                .RuleFor(a => a.Slug, (f, a) => f.Lorem.Slug())
41
                .RuleFor(a => a.Author, f => f.PickRandom(users))
42
                .Generate(1000)
43
        );
44

45
        await dbContext.SaveChangesAsync();
46
    }
47

48
    private async Task RefreshDatabase()
49
    {
50
        using var connection = new NpgsqlConnection(
51
            dbContext
52
                .Database
53
                .GetConnectionString()
54
        );
55

56
        await connection.OpenAsync();
57

58
        var respawner = await Respawner.CreateAsync(connection, new RespawnerOptions
59
        {
60
            TablesToIgnore =
61
            [
62
                "__EFMigrationsHistory"
63
            ],
64
            SchemasToInclude =
65
            [
66
                "public"
67
            ],
68
            DbAdapter = DbAdapter.Postgres
69
        });
70

71
        await respawner.ResetAsync(connection);
72
    }
73
}

1
using Conduit.Business.Extensions;
2
using Conduit.Console.Commands;
3
using Microsoft.Extensions.Configuration;
4
using Microsoft.Extensions.DependencyInjection;
5
using Microsoft.Extensions.Hosting;
6

7
var host = Host.CreateDefaultBuilder(args)
8
    .ConfigureAppConfiguration((hostingContext, config) =>
9
    {
10
        config.AddJsonFile("appsettings.json");
11
    })
12
    .ConfigureServices((context, services) =>
13
    {
14
        services.AddBusinessServices(context.Configuration);
15
        services.AddTransient<SeederCommand>();
16
    })
17
    .Build();
18

19
var seeder = host.Services.GetRequiredService<SeederCommand>();
20
await seeder.SeedAsync();

1
# ...
2

3
[tasks.db-seed]
4
run = "dotnet run"
5
dir = "Conduit.Console"

Lancer mise db-seed pour remplir la base de données avec des utilisateurs et des articles factices. Puis confirmer le fonctionnement de l’endpoint /articles, qui devrait désormais retourner une liste d’articles proprement paginée.

N’hésiter pas à tester que la création fonctionne bien également avec la bonne validation d’unicité du slug et de l’auteur existant.

Tests d’intégration

Nous allons utiliser l’incontournable Testcontainers pour lancer une base de données PostgreSQL éphémère lors de nos tests d’intégration. On utilisera également Respawn pour s’assurer que la base de données est propre avant chaque test.

dotnet new xunit -o Conduit.Tests
dotnet sln add Conduit.Tests

dotnet add Conduit.Tests reference Conduit.WebApi

dotnet add Conduit.Tests package Microsoft.AspNetCore.Mvc.Testing
dotnet add Conduit.Tests package Testcontainers.PostgreSql
dotnet add Conduit.Tests package Respawn

On configure tout d’abord le Host applicatif qui sera l’instance WebApi sur lequel on exécutera tous les tests. Cette instance est configurée pour utiliser une base de données PostgreSQL lancée via Testcontainers.

1
using Conduit.Business.Contexts;
2

3
using Microsoft.AspNetCore.Hosting;
4
using Microsoft.AspNetCore.Mvc.Testing;
5
using Microsoft.EntityFrameworkCore;
6
using Microsoft.Extensions.DependencyInjection;
7

8
using Testcontainers.PostgreSql;
9

10
namespace Conduit.Tests;
11

12
public class ConduitApiFixture : WebApplicationFactory<Program>, IAsyncLifetime
13
{
14
    private readonly PostgreSqlContainer _postgreSqlContainer = new PostgreSqlBuilder()
15
        .WithDatabase("conduit")
16
        .WithUsername("conduit")
17
        .WithPassword("conduit")
18
        .WithImage("postgres:18")
19
        .Build();
20

21
    protected override void ConfigureWebHost(IWebHostBuilder builder)
22
    {
23
        builder
24
            .UseEnvironment("Testing")
25
            .ConfigureServices(services =>
26
            {
27
                var descriptor = services.SingleOrDefault(
28
                    d => d.ServiceType == typeof(DbContextOptions<AppDbContext>));
29

30
                if (descriptor != null)
31
                {
32
                    services.Remove(descriptor);
33
                }
34

35
                services.AddDbContext<AppDbContext>((options) =>
36
                {
37
                    options
38
                        .UseLazyLoadingProxies()
39
                        .UseNpgsql(_postgreSqlContainer.GetConnectionString());
40
                });
41
            });
42
    }
43

44
    private async Task MigrateDatabase()
45
    {
46
        using var scope = Services.CreateScope();
47

48
        using var dbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
49

50
        await dbContext.Database.MigrateAsync();
51
    }
52

53
    public async Task InitializeAsync()
54
    {
55
        await _postgreSqlContainer.StartAsync();
56
        await MigrateDatabase();
57
    }
58

59
    public new async Task DisposeAsync()
60
    {
61
        await _postgreSqlContainer.DisposeAsync();
62
        await base.DisposeAsync();
63
    }
64
}

On crée ensuite une classe de base pour toutes nos classes de tests, qui sera en charge de rafraîchir la base de données avant chaque test.

1
using Conduit.Business.Contexts;
2

3
using Microsoft.EntityFrameworkCore;
4
using Microsoft.Extensions.DependencyInjection;
5

6
using Npgsql;
7

8
using Respawn;
9

10
using Xunit.Abstractions;
11

12
namespace Conduit.Tests;
13

14
[CollectionDefinition(nameof(DatabaseCollectionTest))]
15
public class DatabaseCollectionTest : ICollectionFixture<ConduitApiFixture>;
16

17
[Collection(nameof(DatabaseCollectionTest))]
18
public abstract class TestBase(ConduitApiFixture factory, ITestOutputHelper output) : IAsyncLifetime
19
{
20
    protected ITestOutputHelper Output => output;
21
    protected ConduitApiFixture Factory => factory;
22
    protected AppDbContext DbContext => Factory.Services.GetRequiredService<AppDbContext>();
23

24
    public async Task RefreshDatabase()
25
    {
26
        using var connection = new NpgsqlConnection(
27
            DbContext
28
                .Database
29
                .GetConnectionString()
30
        );
31

32
        await connection.OpenAsync();
33

34
        var respawner = await Respawner.CreateAsync(connection, new RespawnerOptions
35
        {
36
            TablesToIgnore =
37
            [
38
                "__EFMigrationsHistory"
39
            ],
40
            SchemasToInclude =
41
            [
42
                "public"
43
            ],
44
            DbAdapter = DbAdapter.Postgres
45
        });
46

47
        await respawner.ResetAsync(connection);
48

49
        Output.WriteLine("Database refreshed");
50
    }
51

52
    public async Task InitializeAsync()
53
    {
54
        await RefreshDatabase();
55
    }
56

57
    public Task DisposeAsync()
58
    {
59
        return Task.CompletedTask;
60
    }
61
}

Une classe d’exemple basique pour tester la récupération d’un article via l’API.

1
using System.Net;
2
using System.Net.Http.Json;
3

4
using Conduit.WebApi.Dtos;
5

6
using Xunit.Abstractions;
7

8
namespace Conduit.Tests.Articles;
9

10
public class ArticleGetTests(ConduitApiFixture factory, ITestOutputHelper output) : TestBase(factory, output)
11
{
12
    [Fact]
13
    public async Task CannotGetNonExistentArticle()
14
    {
15
        var client = Factory.CreateClient();
16

17
        var response = await client.GetAsync("/articles/slug-article");
18

19
        Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
20
    }
21

22
    [Fact]
23
    public async Task CanGetExistentArticle()
24
    {
25
        var user = await DbContext.Users.AddAsync(new()
26
        {
27
            Name = "johndoe",
28
            Email = "johndoe@example.com",
29
        });
30

31
        await DbContext.Articles.AddAsync(new()
32
        {
33
            Slug = "slug-article",
34
            Title = "Title Article",
35
            Description = "Description Article",
36
            Body = "Body Article",
37
            CreatedAt = DateTime.UtcNow,
38
            UpdatedAt = DateTime.UtcNow,
39
            Author = user.Entity
40
        });
41

42
        await DbContext.SaveChangesAsync();
43

44
        var client = Factory.CreateClient();
45

46
        var response = await client.GetAsync("/articles/slug-article");
47

48
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
49

50
        var articleResponse = await response.Content.ReadFromJsonAsync<ArticleDto>();
51

52
        Assert.Equivalent(new
53
        {
54
            Slug = "slug-article",
55
            Title = "Title Article",
56
            Description = "Description Article",
57
            Body = "Body Article",
58
            Author = new
59
            {
60
                Name = "johndoe",
61
                Email = "johndoe@example.com"
62
            }
63
        }, articleResponse);
64
    }
65
}

1
# ...
2

3
[tasks.test]
4
run = "dotnet test --logger \"console;verbosity=detailed\""

Voilà, il y a tout ce qu’il faut pour bien démarrer, lancer mise test pour exécuter les tests d’intégration. Les conteneurs de DBs seront automatiquement lancés et exécutés lors des tests et tout devrait passer au vert.

Conclusion

Dans cette partie, nous avons mis en place un exemple d’application .NET minimaliste avec une API REST, pushée sur notre instance Gitea. Nous avons vu comment configurer Entity Framework Core avec PostgreSQL, créer des entités et des DTOs, et implémenter des endpoints pour gérer les articles. Nous avons également mis en place des tests d’intégration robustes utilisant Testcontainers pour garantir la fiabilité de notre application.

Il est enfin temps d’en finir dans la dernière partie.