Utilisation de simulations lors des tests unitaires des applications ASP.NET Core

Habituellement, la mise en œuvre de tests unitaires prend du temps et demande des efforts, mais cette tâche peut devenir très simple avec l’aide de Telerik JustMock. Consultez cet article sur la façon de se moquer facilement de votre code et de réussir vos tests.

L’utilisation de mocks est indispensable pour la création de tests unitaires efficaces. Grâce à eux, il devient possible de simuler des scénarios réels, comme rechercher des enregistrements dans une base de données ou faire une requête à une API externe. Telerik a un excellent outil pour aider à créer des simulations—JustMock. Découvrez dans cet article comment implémenter des tests unitaires simulés avec JustMock dans une application ASP.NET Core.

Utilisation de simulations dans les tests unitaires

Les tests unitaires sont un sujet qui a beaucoup retenu l’attention ces derniers temps. Après tout, grâce à lui, nous pouvons vérifier que le code que nous écrivons fonctionne comme prévu. Cela garantit que la logique derrière la fonctionnalité couverte par le test est réellement fonctionnelle et empêche de nombreux bogues d’atteindre l’environnement de production. En effet, le test exécute le code et, si quelque chose ne va pas, le résultat du test l’indiquera.

Bien que l’utilisation de tests automatisés soit fortement recommandée dans les projets logiciels, plusieurs situations peuvent rendre difficile l’utilisation de cette pratique.

Certains aspects qui rendent généralement difficile l’utilisation de tests automatisés sont :

• Dépendances entre différents logiciels, tels que la couche de service qui accède à la couche de base de données.
• Intégrations avec des partenaires qui ne fournissent pas d’environnements appropriés pour les tests

Pour résoudre ce problème, des simulations sont souvent utilisées afin de créer une simulation du comportement attendu.

Les mocks sont des constructions qui émulent le comportement d’un objet et permettent de valider les structures qui en dépendent, comme les tests unitaires.

Pour aider à la mise en œuvre de techniques de test simulées, il existe une excellente option disponible chez Telerik avec JustMock. Rapide, flexible et complet, JustMock est l’outil parfait pour créer des tests unitaires dans des solutions .NET intégrées.

Cet article explique comment implémenter des tests unitaires efficaces à l’aide de JustMock dans une application Web .NET 6.

À propos du projet

Le projet sera une API minimale dans .NET 6 qui conservera certains exemples de données lorsque la base de données est générée via les commandes EF Core et aura un point de terminaison pour renvoyer les enregistrements. Ensuite, un projet de test avec Telerik JustMock sera mis en œuvre avec un test unitaire utilisant des simulations pour couvrir les principales parties du code. Trouvez le code source ici.

Conditions préalables

• Bibliothèque Telerik JustMock
• Visual Studio 2022
• SDK .NET 6

Création du projet

Pour créer le projet dans Visual Studio :

• Créer un nouveau projet
• Choisissez « API Web ASP.NET Core »
• Nommez le projet (« Entrepôt » est suggéré)
• Choisissez « .NET 6 (support à long terme) »
• Décochez « Utiliser les contrôleurs »
• Créer

Dépendances

Voici les dépendances du projet :

<ItemGroup>
    <PackageReference Include="JustMock.Commercial" Version="2022.1.223.1" />
    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.2.3" />
	  <PackageReference Include="Microsoft.EntityFrameworkCore" Version="6.0.3" />
	  <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="6.0.3">
		  <PrivateAssets>all</PrivateAssets>
		  <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
	  </PackageReference>
	  <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="6.0.3" />
	  <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="6.0.3">
		  <PrivateAssets>all</PrivateAssets>
		  <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
	  </PackageReference>
  </ItemGroup>

Des modèles

Créez un dossier « Models » et, à l’intérieur de celui-ci, la classe suivante :

namespace Warehouse.Models
{
     public class Order
     {
         public int Id { get; set; }
         public string? ProductName { get; set; }
         public int Quantity { get; set; }
         public bool IsCompleted { get; set; }
     }
}

Création du contexte de base de données

La classe de contexte contient les paramètres de la base de données. Grâce à Entity Framework Core et SQLite, toute la configuration et la création de bases de données seront simplifiées.

Créez donc un nouveau dossier « Data » et créez à l’intérieur la classe ci-dessous :

using Microsoft.EntityFrameworkCore;
using Warehouse.Models;

namespace Warehouse.Data
{
    public class ApplicationDbContext : DbContext
    {
        public DbSet<Order> Orders { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder options)
            => options.UseSqlite("DataSource = warehouse_db; Cache=Shared");

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            var seedData = Enumerable.Range(1, 11).Select(i => new Order
            {
                Id = i,
                Quantity = i * 10,
                ProductName = "ProductExample" + i,
            }).ToList();

            modelBuilder.Entity<Order>().HasData(
                seedData[0], seedData[1], seedData[2], seedData[3], seedData[4], seedData[5],
                seedData[6], seedData[7], seedData[8], seedData[9], seedData[10]);
        }
    }
}

Dans le fichier Program.cs ajoutez la ligne de code suivante :

builder.Services.AddDbContext<ApplicationDbContext>();

Exécution des commandes EF Core

Pour que la base de données soit créée, il est nécessaire d’exécuter les commandes ci-dessous :

• dotnet ef migrations add InitialModel
• dotnet ef database update

Prestations de service

La classe de service communique avec la classe de contexte ; il sera accessible par le point de terminaison de l’API. Créez un dossier « Services » et, à l’intérieur de celui-ci, la classe suivante :

using Warehouse.Data;
using Warehouse.Models;

namespace Warehouse.Services
{
    public class WarehouseService
    {
        private readonly ApplicationDbContext _dbContext;

        public WarehouseService(ApplicationDbContext dbContext)
        {
            _dbContext = dbContext;
        }
        public virtual List<Order> GetOrders() => _dbContext.Orders.ToList();
    }
}

Programme

Remplacez le code du fichier Program.cs par ce qui suit :

using Warehouse.Data;
using Warehouse.Services;

var builder = WebApplication.CreateBuilder(args);



builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
builder.Services.AddDbContext<ApplicationDbContext>();
builder.Services.AddScoped<WarehouseService>();

var app = builder.Build();


if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.MapGet("/orders", (WarehouseService service) =>
{
    return Results.Ok(service.GetOrders());

}).WithName("GetOrders");

app.Run();

Le code ci-dessus :

• Ajoute l’injection de dépendance des classes ApplicationDbContext et WarehouseService.
• Crée un point de terminaison (/orders) pour récupérer les enregistrements dans la base de données.

Exécution du projet

Nous exécuterons le projet juste pour vérifier que l’application fonctionne. Si tout s’est bien passé, le panneau Swagger suivant s’affichera.

Mise en œuvre du projet de test

Pour créer le projet de test, il est nécessaire d’avoir installé l’outil JustMock. Ensuite, suivez les étapes ci-dessous :

• Faites un clic droit sur le projet de solution
• Ajouter
• Nouveau projet
• Sélectionnez « Projet de test C # JustMock (.NET Core) »
• Nommez le projet (« Warehouse.JustMockTest » est suggéré)
• Créer

Remplacez le contenu existant dans la classe « JustMockTest » par le code ci-dessous :

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Telerik.JustMock;
using Warehouse.Data;
using Warehouse.Models;
using Warehouse.Services;

namespace Warehouse.JustMockTest
{
    
    
    
    [TestClass]
    public class JustMockTest
    {
        [TestMethod]
        public void GetOrders_AreEqualsOne()
        {
            
            var dbContext = new ApplicationDbContext();
            Mock.Arrange(() => dbContext.Orders).ReturnsCollection(FakeOrders());
            
WarehouseService service = Mock.Create<WarehouseService>();
            Mock.Arrange(() => service.GetOrders()).Returns(dbContext.Orders.ToList());

            
            var query = from o in dbContext.Orders
                        where o.Id == 1
                        select o;

            var queryService = from s in service.GetOrders()
                               where s.Id == 1
                               select s;

            
            Assert.AreEqual(1, query.Count());
            Assert.AreEqual(1, query.First().Id);

            Assert.AreEqual(1, queryService.Count());
            Assert.AreEqual(1, queryService.First().Id);
        }

        public IList<Order> FakeOrders()
        {
            var order = new Order();
            order.Id = 1;
            order.ProductName = "Smartphone";
            order.Quantity = 53;
            order.IsCompleted = true;

            var fakeOrders = new List<Order>();
            fakeOrders.Add(order);

            return fakeOrders;
        }
    }
}

Le code ci-dessus :

• Définit une classe de test par la [TestClass] attribut
• Définit une méthode de test par la [TestMethod] attribut
• Contient une méthode (FakeOrders) qui génère une liste de faux ordres à utiliser dans la méthode d’exécution Test. Il est recommandé de créer de faux objets dans des méthodes distinctes, car ils peuvent être réutilisés dans d’autres méthodes.
• Contient une méthode « GetOrders_AreEqualsOne» responsable de l’exécution du test.

Dans le GetOrders_AreEqualsOne méthode, la classe de contexte mock est créée, où le résultat attendu est défini via la méthode (ReturnsCollection(FakeOrders()), malgré le dbContext.Orders utilisé.

Lorsque le test est exécuté, aucune requête n’est effectuée dans la base de données – après tout, nous affectons la valeur de retour de la méthode (FakeOrders()) à cette liste, c’est-à-dire en se moquant de la classe et de l’objet renvoyé par la méthode.

Ensuite, la méthode de classe de service est également simulée et renvoie les données de contexte, qui sont fausses, car elles ont été simulées.

Enfin, nous parcourons les listes et comparons le résultat avec la valeur 1, ce qui signifie que les listes ne sont pas vides – elles contiennent la valeur fictive des commandes, ce qui fait passer le test sans problème.

Important: Vous devez activer JustMock dans le projet, sinon lors de l’exécution du test une erreur s’affichera. Pour l’activer, dans Visual Studio, cliquez sur le bouton « Extensions » situé en haut. Puis « JustMock » et enfin « Activer Profiler ».

Exécution des tests unitaires

Si vous exécutez les tests via Visual Studio Test Explorer, vous verrez que le test a réussi, comme illustré dans l’image ci-dessous :

Conclusion

La création de tests unitaires peut devenir une tâche simple avec l’aide de JustMock. Dans cet article, nous avons créé une application simple dotée d’un point de terminaison pour récupérer certains enregistrements de la base de données. Ensuite, nous avons créé un projet de test avec JustMock et nous nous sommes moqués de toutes les classes et méthodes principales présentes dans le code, en nous assurant qu’elles fonctionnaient comme prévu.

Il existe de nombreuses autres possibilités en utilisant JustMock– n’hésitez pas à les explorer.