Back to "(Simple) Eenheidstest De Blog-Teile 1 - Diensten"

This is a viewer only at the moment see the article on how this works.

To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk

This is a preview from the server running through my markdig pipeline

Moq Unit Testing xUnit

(Simple) Eenheidstest De Blog-Teile 1 - Diensten

Sunday, 25 August 2024

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.

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 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.
  3. Performancetesting - Testen hoe je applicatie werkt onder druk. Dit kan met tools als: Apache JMeter, PostMan. Mijn voorkeur is echter een tool genaamd k6.
  4. Beveiligingstest - Testen hoe veilig je applicatie is. Dit kan gedaan worden met tools zoals OWASP ZAP, Burp Suite, Nessus.
  5. Endgebruikertesting - Testen hoe je toepassing werkt voor de eindgebruiker. Dit kan gedaan worden met tools zoals Gebruikertest, UserZoom, Userlytica.

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.

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:

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:

  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.

    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.

 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.

    [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

    [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 .

logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.