# (Simple) Eenheidstest De Blog-Teile 1 - Diensten

<datetime class="hidden">2024-08-25T23:00</datetime>

<!--category-- xUnit, Moq, Unit Testing -->
## Inleiding

In deze post zal ik Unit Testing beginnen te toevoegen voor deze site. Dit zal niet een volledige tutorial over Unit Testen zijn, maar eerder een reeks posten over hoe ik Unittesting aan deze site zou toevoegen.
In deze post test ik een aantal diensten door DbContext te bespotten; dit is om enige DB-specifieke schanigans te voorkomen.

[TOC]

## Waarom eenheidstest?

Eenheidstesting is een manier om individuele onderdelen van je code te testen in isolement.

1. Het isoleert elk onderdeel van je code waardoor het makkelijk is om problemen te zien in specifieke gebieden.
2. Het is een manier om je code te documenteren.

### Welke andere tests zijn er??

Er zijn een aantal andere soorten testen die je kunt doen.. Hier zijn er een paar.

1. Integratietesting - Testen hoe verschillende componenten van je code samenwerken. [Bevestig](https://github.com/VerifyTests/Verify) om de output van de eindpunten te testen en ze met de verwachte resultaten te vergelijken.
2. End-to-Endtesting - De hele applicatie testen vanuit het perspectief van de gebruikerMST3Mst4 Dit kan gedaan worden met tools zoals [Selenium](https://www.selenium.dev/).
3. Performancetesting - Testen hoe je applicatie werkt onder druk. Dit kan met tools als: [Apache JMeter](https://jmeter.apache.org/), [PostMan](https://www.postman.com/). Mijn voorkeur is echter een tool genaamd [k6](https://k6.io/).
4. Beveiligingstest - Testen hoe veilig je applicatie is. Dit kan gedaan worden met tools zoals [OWASP ZAP](https://www.zaproxy.org/), [Burp Suite](https://portswigger.net/burp), [Nessus](https://www.tenable.com/products/nessus).
5. Endgebruikertesting - Testen hoe je toepassing werkt voor de eindgebruiker. Dit kan gedaan worden met tools zoals [Gebruikertest](https://www.usertesting.com/), [UserZoom](https://www.userzoom.com/), [Userlytica](https://www.userlytics.com/).

## Opstelling van het toetsproject

I'm ga xUnit gebruiken voor mijn tests. Dit is standaard gebruikelijk in ASP~.~NET Coreprojecten~. I 'm gaat ook Moq gebruiken om de DbContext te verbeelden.

- MoqQueryable - Dit heeft nuttige uitbreidingen voor het mokken van IQueryables objecten.
- Moq.EntityFrameworkCore - Dit heeft nuttige uitbreidingen om DbContext objecten te mokken.

## De DbContext verplaatsen

In de voorbereiding voegde ik een interface toe voor mijn DbContext. zodat ik de Dbcontext in mijn tests kan afbeelden.

```csharp
namespace Mostlylucid.EntityFramework;

public interface IMostlylucidDBContext
{
    public DbSet<CommentEntity> Comments { get; set; }
    public DbSet<BlogPostEntity> BlogPosts { get; set; }
    public DbSet<CategoryEntity> Categories { get; set; }

    public DbSet<LanguageEntity> Languages { get; set; }
    
    public DatabaseFacade Database { get; }
    
    Task<int> SaveChangesAsync(CancellationToken cancellationToken = default);

}

```

Het is vrij simpel, gewoon onze DBSets en de SaveChangesAsync-methode blootleggen.

Ik *Don't* Ik gebruik een bibliotheekpatroon in mijn code. Dit komt omdat de 'Entity Framework Core' al een biblioteekpatron is.

Dan voegen we een nieuwe klas toe. `Mostlylucid.Test` Het project met een uitbreidingsmethode om onze zoekopdracht op te zetten:

```csharp
public static class MockDbSetExtensions
{
    public static Mock<DbSet<T>> CreateDbSetMock<T>(this IEnumerable<T> sourceList) where T : class
    {
        // Use the MockQueryable.Moq extension method to create the mock
        return sourceList.AsQueryable().BuildMockDbSet();
    }

    // SetupDbSet remains the same, just uses the updated CreateDbSetMock
    public static void SetupDbSet<T>(this Mock<IMostlylucidDBContext> mockContext, IEnumerable<T> entities,
        Expression<Func<IMostlylucidDBContext, DbSet<T>>> dbSetProperty) where T : class
    {
        var dbSetMock = entities.CreateDbSetMock();
        mockContext.Setup(dbSetProperty).Returns(dbSetMock.Object);
    }
}
```

Je ' zal zien dat dit de `MockQueryable.Moq` Uitbreidingsmethode om het model te maken. Die vervolgens onze IQueryable objecten en IAsyncQueryables opstelt.

### Opstelling van de test

Een kernprincipe van Unit Testing is dat elke test een 'unit' werk moet zijn en niet afhangt van het resultaat van enig ander test.

In onze nieuwe `BlogServiceFetchTests` We hebben onze test-context opgezet in de constructor:

```csharp
  public BlogServiceFetchTests()
    {
        // 1. Setup ServiceCollection for DI
        var services = new ServiceCollection();
        // 2. Create a mock of IMostlylucidDbContext
        _dbContextMock = new Mock<IMostlylucidDBContext>();
        // 3. Register the mock of IMostlylucidDbContext into the ServiceCollection
        services.AddSingleton(_dbContextMock.Object);
        // Optionally register other services
        services.AddScoped<IBlogService, EFBlogService>(); // Example service that depends on IMostlylucidDbContext
        services.AddLogging(configure => configure.AddConsole());
        services.AddScoped<MarkdownRenderingService>();
        // 4. Build the service provider
        _serviceProvider = services.BuildServiceProvider();
    }
```

Ik heb dit heel erg gecommenteerd, zodat je kunt zien wat er aan de hand is. `ServiceCollection` Dit is een verzameling van diensten die we kunnen gebruiken in onze tests. `IMostlylucidDBContext` en het in de registers registeren. `ServiceCollection`. We registreren dan alle andere diensten die we nodig hebben voor onze tests. `ServiceProvider` Die kunnen we gebruiken om onze diensten te krijgen van.

## De test schrijven

Ik begon met het toevoegen van een enkele testklas, ,, de vorige. `BlogServiceFetchTests` class. Dit is een testklas voor de Post-methoden van mijn examen. `EFBlogService` Klas.

Elke test gebruikt een gemeenschappelijke `SetupBlogService` methode om een nieuwe populatie te krijgen. `EFBlogService` object. Zo kunnen we de dienst isoleerlijk testen.

```csharp
    private IBlogService SetupBlogService(List<BlogPostEntity>? blogPosts = null)
    {
        blogPosts ??= BlogEntityExtensions.GetBlogPostEntities(5);

        // Setup the DbSet for BlogPosts in the mock DbContext
        _dbContextMock.SetupDbSet(blogPosts, x => x.BlogPosts);

        // Resolve the IBlogService from the service provider
        return _serviceProvider.GetRequiredService<IBlogService>();
    }

```

### BlogEntityExtensions

Dit is een eenvoudige uitbreidingsklas die ons een aantal gepopulate soorten geeft. `BlogPostEntity` objecten. Zo kunnen we onze dienst testen met een aantal verschillende objecten.

```csharp
 public static List<BlogPostEntity> GetBlogPostEntities(int count, string? langName = "")
    {
        var langs = LanguageExtensions.GetLanguageEntities();

        if (!string.IsNullOrEmpty(langName)) langs = new List<LanguageEntity> { langs.First(x => x.Name == langName) };

        var langCount = langs.Count;
        var categories = CategoryEntityExtensions.GetCategoryEntities();
        var entities = new List<BlogPostEntity>();

        var enLang = langs.First();
        var cat1 = categories.First();

        // Add a root post to the list to test the category filter.
        var rootPost = new BlogPostEntity
        {
            Id = 0,
            Title = "Root Post",
            Slug = "root-post",
            HtmlContent = "<p>Html Content</p>",
            PlainTextContent = "PlainTextContent",
            Markdown = "# Markdown",
            PublishedDate = DateTime.ParseExact("2025-01-01T07:01", "yyyy-MM-ddTHH:mm", CultureInfo.InvariantCulture),
            UpdatedDate = DateTime.ParseExact("2025-01-01T07:01", "yyyy-MM-ddTHH:mm", CultureInfo.InvariantCulture),
            LanguageEntity = enLang,
            Categories = new List<CategoryEntity> { cat1 }
        };
        entities.Add(rootPost);
        for (var i = 1; i < count; i++)
        {
            var langIndex = (i - 1) % langCount;
            var language = langs[langIndex];
            var postCategories = categories.Take(i - 1 % categories.Count).ToList();
            var dayDate = (i + 1 % 30 + 1).ToString("00");
            entities.Add(new BlogPostEntity
            {
                Id = i,
                Title = $"Title {i}",
                Slug = $"slug-{i}",
                HtmlContent = $"<p>Html Content {i}</p>",
                PlainTextContent = $"PlainTextContent {i}",
                Markdown = $"# Markdown {i}",
                PublishedDate = DateTime.ParseExact($"2025-01-{dayDate}T07:01", "yyyy-MM-ddTHH:mm",
                    CultureInfo.InvariantCulture),
                UpdatedDate = DateTime.ParseExact($"2025-01-{dayDate}T07:01", "yyyy-MM-ddTHH:mm",
                    CultureInfo.InvariantCulture),
                LanguageEntity = new LanguageEntity
                {
                    Id = language.Id,
                    Name = language.Name
                },
                Categories = postCategories
            });
        }

        return entities;
    }
```

Je kunt zien dat dit alles een stel aantal blogposts terugbrengt met talen en categorieën. Maar we voegen altijd een 'rootM SK2 voorwerp toe waardoor we ons kunnen vertrouwen op een bekend voorwerp in onze tests.

### De tests

Elke test is ontworpen om één aspect van de postresultaten te testen.

Bijvoorbeeld in de twee onder testen we simpelweg dat we alle posts kunnen krijgen en dat we posten kunnen krijgen per taal.

```csharp
    [Fact]
    public async Task TestBlogService_GetBlogsByLanguage_ReturnsBlogs()
    {
        var blogService = SetupBlogService();

        // Act
        var result = await blogService.GetPostsForLanguage(language: "es");

        // Assert
        Assert.Single(result);
    }

    [Fact]
    public async Task TestBlogService_GetAllBlogs_ReturnsBlogs()
    {
        var blogs = BlogEntityExtensions.GetBlogPostEntities(2);
        var blogService = SetupBlogService(blogs);
        // Act
        var result = await blogService.GetAllPosts();

        // Assert
        Assert.Equal(2, result.Count());
    }
```

#### Testen voor falen

Een belangrijk concept in eenheidstesting is 'test falen' waarbij je vastlegt dat je code faalt zoals je verwacht.

In de tests onder toetsen we eerst of onze pagingcode werkt zoals verwacht. Daarna testen we dat als we meer pagina's vragen dan we hebben, we een leeg resultaat krijgen ( en geen fouten

```csharp
    [Fact]
    public async Task TestBlogServicePagination_GetBlogsByCategory_ReturnsBlogs()
    {
        var blogPosts = BlogEntityExtensions.GetBlogPostEntities(10, "en");
        var blogService = SetupBlogService(blogPosts);

        // Act
        var result = await blogService.GetPagedPosts(2, 5);

        // Assert
        Assert.Equal(5, result.Posts.Count);
    }

    [Fact]
    public async Task TestBlogServicePagination_GetBlogsByCategory_FailsBlogs()
    {
        var blogPosts = BlogEntityExtensions.GetBlogPostEntities(10, "en");
        var blogService = SetupBlogService(blogPosts);

        // Act
        var result = await blogService.GetPagedPosts(10, 5);

        // Assert
        Assert.Empty(result.Posts);
    }
```

## In slotting:

Dit is een eenvoudig begin voor ons Unit Testing. In de volgende post voegen we'tests toe voor meer diensten en eindpuntenM SK2 WeMSC3 zullen ook kijken naar hoe we onze eindpunten kunnen testen met Integrationstests .