Test C # .NET Applications: unité, intégration et tests de bout en bout

Les stratégies de test des applications

C # .NET incluent les tests unitaires, les tests d'intégration et les tests de bout en bout. 1. Le test unitaire garantit que l'unité minimale du code fonctionne indépendamment, en utilisant le cadre MSTEST, NUnit ou Xunit. 2. Les tests intégrés vérifient les fonctions de plusieurs unités combinées et des données simulées couramment utilisées et des services externes. 3. Les tests de bout en bout simulent le processus de fonctionnement complet de l'utilisateur, en utilisant généralement le sélénium pour les tests automatisés.

introduction

Dans le monde du développement de logiciels, les tests sont comme un filet de sécurité pour le code que nous écrivons. Surtout lors du développement avec C # et .NET, le test n'est pas seulement une étape critique pour assurer la qualité de votre code, mais aussi un art. Aujourd'hui, nous plongerons dans les stratégies de test pour les applications C # .NET, y compris les tests unitaires, les tests d'intégration et les tests de bout en bout. Grâce à cet article, vous apprendrez à tester efficacement votre application C # et à comprendre les avantages et les défis de différents types de tests.

Examen des connaissances de base

Les tests sont partout dans le développement de logiciels, mais nous devons clarifier plusieurs types de tests majeurs. Les tests unitaires se concentrent sur la plus petite unité de code, généralement une méthode ou une fonction. Les tests d'intégration vérifient si plusieurs unités fonctionnent correctement ensemble. Des tests de bout en bout simulent le processus de fonctionnement complet de l'utilisateur pour s'assurer que l'ensemble du système fonctionne comme prévu.

Dans C # .NET, nos cadres de test couramment utilisés incluent MSTEST, NUnit et Xunit. Ces cadres fournissent une multitude d'outils et d'API pour nous aider à rédiger et à exécuter des tests.

Analyse du concept de base ou de la fonction

Définition et fonction des tests unitaires

Les tests unitaires sont la granularité minimale du test, qui garantit que chaque unité de code fonctionne indépendamment. Grâce aux tests unitaires, nous pouvons rapidement localiser et résoudre les problèmes et améliorer la maintenabilité et la fiabilité de notre code. Le cœur des tests unitaires est son indépendance et sa rétroaction rapide.

Un exemple de test unitaire simple:

 en utilisant xunit;

Calculatortes de classe publique
{
    [Fait]
    public void add_twophiaceinumbers_returnsCorrectSum ()
    {
        // Organiser
        Var Calculator = nouveau calculatrice ();

        // Acte
        Var Result = Calculate.Add (2, 3);

        // affirmer
        Assert.equal (5, résultat);
    }
}

Ce code montre un test unitaire d'une simple opération d'addition. De cette façon, nous pouvons nous assurer que la méthode Add dans Calculator fonctionne correctement sous diverses entrées.

Comment fonctionne les tests d'intégration

Le but des tests d'intégration est de vérifier la fonctionnalité de plusieurs unités combinées. Il fonctionne en simulant le flux de données et l'interaction dans un environnement réel, garantissant que les composants peuvent fonctionner de manière transparente. Les tests d'intégration nécessitent souvent plus de données de configuration et de simulation, mais elles peuvent détecter des problèmes d'intégration que les tests unitaires ne peuvent pas capturer.

Un exemple de test d'intégration:

 en utilisant xunit;

Classe publique pour lesservites
{
    [Fait]
    tâche asynchrone publique getuser_validuserid_returnSuser ()
    {
        // Organiser
        var userservice = new userService (new FakeUserRepository ());
        var userId = "123";

        // Acte
        var user = attend userservice.getUser (userId);

        // affirmer
        Assert.notnull (utilisateur);
        Assert.equal ("John Doe", user.name);
    }
}

Dans cet exemple, nous avons testé la classe UserService , qui s'appuie sur un référentiel d'utilisateurs. Nous utilisons un faux référentiel pour simuler des sources de données réelles, vérifiant ainsi la logique de la couche de service.

Le principe de mise en œuvre des tests de bout en bout

Des tests de bout en bout simulent le processus opérationnel complet des utilisateurs, impliquant généralement des opérations d'interaction et de base de données d'interface utilisateur. Son principe d'implémentation consiste à simuler le comportement des utilisateurs via des outils d'automatisation (tels que le sélénium) et de vérifier si les fonctions du système du début à la fin sont normales.

Un exemple de test de bout en bout:

 en utilisant xunit;
Utilisation d'OpenQA.Selenium;
en utilisant openqa.selenium.chrome;

Logonds de classe de classe publique
{
    [Fait]
    public void Login_validCredentials_redirectStodashboard ()
    {
        // Organiser
        Iwwebdriver Driver = new ChromEdriver ();
        driver.navigate (). gotourl ("https://example.com/login");

        // Acte
        Driver.Findelement (by.id ("nom d'utilisateur")). SendKeys ("utilisateur");
        Driver.Findelement (by.id ("mot de passe")). SendKeys ("mot de passe");
        Driver.FindElement (by.id ("LoginButton")). Click ();

        // affirmer
        Assert.Contains ("Dashboard", Driver.Title);
        driver.Quit ();
    }
}

Cet exemple montre comment utiliser le sélénium pour des tests de bout en bout, simuler les opérations de connexion des utilisateurs et vérifier qu'il passe avec succès au tableau de bord.

Exemple d'utilisation

Utilisation de base des tests unitaires

L'utilisation de base des tests unitaires est d'écrire des méthodes de test indépendantes, chacune testant une fonction ou un comportement spécifique. Voici un exemple simple:

 en utilisant xunit;

classe publique StringCalculatortests
{
    [Fait]
    public void add_emptystring_returnszero ()
    {
        var calcul = new StringCalculator ();
        var result = calcul.add ("");
        Assert.equal (0, résultat);
    }

    [Fait]
    public void add_singlenumber_returnsNumber ()
    {
        var calcul = new StringCalculator ();
        var result = calculer ("5");
        Assert.equal (5, résultat);
    }
}

Ces méthodes de test testent le comportement de la méthode Add de StringCalculator sous des chaînes vides et des entrées numériques uniques, respectivement.

Utilisation avancée des tests d'intégration

L'utilisation avancée des tests d'intégration comprend des services externes et des opérations de base de données. Voici un exemple d'utilisation de la bibliothèque MOQ pour simuler les services externes:

 en utilisant xunit;
en utilisant le moq;

ORDERSERVICETESTS DE CLASSE PUBLIQUE
{
    [Fait]
    Public Async Task PlaceOrder_ValidOrder_CALLSPAYSERVICE ()
    {
        // Organiser
        var mockPaymentservice = new Mock <ipaymentsVice> ();
        var orderService = new OrderService (mockpaymentservice.object);
        var ordonnance = new Ordre {montant = 100};

        // Acte
        AWAIT ORDERSERVICE.Placeorder (Order);

        // affirmer
        mockpaymentservice.verify (ps => ps.processPayment (ordonnance.amount), times.once);
    }
}

Dans cet exemple, nous utilisons la bibliothèque MOQ pour simuler le service de paiement et vérifions que OrderService appelle correctement le service de paiement lors de la commande.

Erreurs communes et conseils de débogage pour les tests de bout en bout

Les erreurs courantes dans les tests de bout en bout incluent les échecs de positionnement des éléments, le temps d'attente insuffisant, etc. Voici quelques conseils de débogage:

• Utilisez des attentes explicites pour vous assurer que l'élément charge:

 var wait = new WebDriverWait (pilote, timeSpan.fromSeconds (10));
var element = wait.until (d => d.findement (by.id ("myelement")));

• Utilisez la journalisation pour suivre le processus d'exécution du test pour aider à localiser les problèmes:

 Utilisation de Microsoft.Extensions.logging;

Logonds de classe de classe publique
{
    Private ReadOnly Ilogger <LogIntests> _Logger;

    Public LogIntests (ILogger <LogIntests> Enregistreur)
    {
        _Logger = Logger;
    }

    [Fait]
    public void Login_validCredentials_redirectStodashboard ()
    {
        _Logger.logInformation ("Démarrage de connexion");
        // ... code de test ...
        _Logger.logInformation ("Test de connexion terminée");
    }
}

Optimisation des performances et meilleures pratiques

L'optimisation des performances et les meilleures pratiques sont cruciales lors du test des applications C # .NET. Voici quelques suggestions:

• Couverture de test : assurez-vous que vos tests couvrent les chemins de code critiques. Utilisez un outil tel que la couverture pour mesurer la couverture des tests:

 DotNet Test / P: CollectCoverage = True / P: CoverletOutputTormat = lcov /p:CoverletOutput=./coverage/lcov.info

• Parallélisation des tests : utilisez la fonction de parallélisation du cadre de test pour accélérer l'exécution du test. Par exemple, dans Xunit, l'exécution parallèle des tests peut être contrôlée via l'attribut [collection] :

 [Collection ("MyCollection")]
Mytests de classe publique
{
    // Méthode de test}

• Code de lisibilité : écrivez le code de test clair et concis avec des noms et commentaires significatifs:

 [Fait]
public void CalculaTetotalprice_WithDiscount_ApplyDiscountCorrectly ()
{
    // Organiser
    var ordonnance = new Order {prix = 100, remise = 10};

    // Acte
    var totalPrice = order.CalculaTetotalPrice ();

    // affirmer
    Assert.equal (90, TotalPrice); // 100 - 10% = 90
}

Grâce à ces stratégies et pratiques, nous pouvons non seulement améliorer l'efficacité et la qualité des tests, mais aussi nous assurer que nos applications C # .NET peuvent fonctionner de manière stable dans divers scénarios. J'espère que cet article vous fournira des idées précieuses et des conseils pratiques pour vous aider à aller plus loin sur la voie des tests.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!