Lorsque vous travaillez sur des tests unitaires, il existe des scénarios où vous auriez souhaité que l’exécution s’arrête, mais hélas, la partie la plus importante, « L’assertion », a été manquée. Lors du développement de tests à l’aide de différents frameworks de test, mes collègues développeurs ont fréquemment posé une question : « Dois-je utiliser une assertion ou une exception dans mon code de test ? » Cela dépend de ce que le code de test doit faire une fois qu’une certaine condition est remplie.
À la fin de cet article, vous obtiendrez des informations détaillées sur les assertions NUnit et sur la façon dont ces assertions peuvent être utilisées avec C# et Selenium. Je vais vous expliquer les bases des assertions et quand les assertions doivent être utilisées pour commencer. Nous couvrirons les contraintes suivantes (discutées plus tard) utilisées avec l’assertion NUnit :
- Contraintes égales
- Contraintes de comparaison
- Contraintes de chaîne
- Contraintes de condition
- Contraintes de collecte
Si vous connaissez déjà les contraintes, vous pouvez vous diriger directement vers les sections (Asserts NUnit, Asserts en action et NUnit, et Cross Browser Testing) qui illustrent l’utilisation de l’assertion NUnit dans le contexte des tests d’automatisation Selenium.
Que sont les affirmations ?
En termes très simples, les assertions devraient être utilisées pour vérifier quelque chose (une condition) qui ne devrait jamais se produire, tandis qu’une exception devrait être utilisée pour vérifier quelque chose (une condition) qui pourrait se produire. Par exemple, lorsqu’une opération de division est utilisée, une exception peut être levée si vous obtenez l’erreur « Diviser par 0 ». D’un autre côté, lors de l’utilisation des tests d’automatisation Selenium avec C# (ou un autre langage de programmation), une assertion peut être levée si le titre de la page ne correspond pas au titre attendu.
Vous trouverez ci-dessous une liste détaillée qui met en évidence l’utilisation des assertions :
- Fournir des commentaires sur le code source à l’équipe de développement.
- Vérifiez si l’implémentation est correcte, sinon il pourrait y avoir un problème grave avec le code.
- Vérifiez les préconditions et postconditions qui peuvent apparaître dans le code.
Et si vous ne vous affirmiez pas au bon endroit ? Eh bien, c’est comme dans la situation illustrée ci-dessous – marcher dans des escaliers où les marches sont cassées, vous risquez de vous blesser .
Le cadre NUnit
Le framework NUnit est un framework de test open source largement utilisé utilisé avec C# et Selenium. Il est basé sur le framework JUnit. La dernière version est NUnit3.
Lors de l’utilisation de C# pour le développement et les tests, j’ai essayé d’autres frameworks de test, MSTest/Visual Studio, xUnit.NET, etc., les avantages de NUnit surpassant les différents frameworks. Les annotations dans NUnit permettent d’accélérer le développement et l’exécution des tests avec une large gamme d’entrées.
Si vous prévoyez d’utiliser TDD (développement piloté par les tests) pour les tests, vous devriez essayer le framework NUnit. Si vous recherchez une couverture approfondie du framework NUnit avec Selenium ainsi que des étapes d’installation sur Visual Studio, vous devriez consulter le didacticiel NUnit sur la configuration des environnements NUnit avec Visual Studio plus en détail.
Organiser, agir et affirmer
Le AAA (Arrange, Act, and Assert) est une pratique courante pour écrire des tests unitaires.
Arrange— Cette section décrit la configuration requise pour exécuter le test.Act— Cette section exécute l’unité testée, la sortie étant un magasin pour évaluation.Assert— Cette section vérifie si les tests se sont comportés conformément aux attentes.
De nombreux développeurs utilisent Given, When, et Then au lieu de AAA car cela donne un sens plus descriptif à ces phrases, et de nombreux outils BDD utilisent également ces phrases pour nommer leurs mots-clés de test.
L’avantage de l’approche AAA est que les tests deviennent plus modulaires, améliorant ainsi la lisibilité des tests.
Assertions dans NUnit
NUnit possède un riche ensemble d’assertions, qui sont des méthodes statiques de la classe Assert.
Cependant, de nombreux développeurs ont plusieurs assertions dans un test, mais ce n’est pas une bonne pratique de programmation car les tests suivant la première assertion NUnit ne sont pas exécutés. Par conséquent, il est recommandé de n’avoir qu’une seule assertion NUnit par test.
Avant NUnit 2.4, le modèle classique était utilisé pour utiliser les assertions NUnit. Dans ce modèle, chaque assertion NUnit a été utilisée via une méthode distincte de la classe Assert. À partir de NUnit 2.4, un modèle de contrainte a été introduit dans lequel une seule méthode de classe Assert a été utilisée. L’objet de contrainte est passé en argument avec les détails du test qui doit être effectué.
Cours d’aide
Les classes d’assistance en C# sont des classes qui fournissent des méthodes qui « aident/aident » à faire quelque chose. Vous trouverez ci-dessous les classes d’assistance pour fournir des contraintes à la méthode assert.
- Est
- A
- Jetés
- Contient
- Fait
Assert.That( myString, Is.EqualTo("LambdaTest") );Dans l’exemple qui a été montré ci-dessus, Is est la classe d’assistance, et EqualTo est la contrainte.
Contraintes dans NUnit assert
Il existe huit grandes catégories de contraintes :
1. Contraintes égales
Cette catégorie de contrainte permet de comparer le résultat attendu avec le résultat réel. L’opération Equal peut être pour l’égalité (EqualTo) et la non-égalité (NotEqualTo)
une. Égal à. Il est utilisé pour vérifier si le résultat réel est le même que le résultat attendu. Si les résultats ne sont pas les mêmes, assert est déclenché.
Syntaxe:
Is.EqualTo( object expected )Voici un exemple de test d’automatisation Selenium qui démontre l’utilisation de EqualTo contrainte.
Nom de fichier : 1_Equal_To_Constraint.cs
using NUnit.Framework;
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Firefox;
using OpenQA.Selenium.IE;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Assert_Demo
{
public class Browser_ops
{
IWebDriver webDriver;
public void Init_Browser()
{
webDriver = new ChromeDriver();
webDriver.Manage().Window.Maximize();
}
public string Title
{
get { return webDriver.Title; }
}
public void Goto(string url)
{
webDriver.Url = url;
}
public string Geturl
{
get { return webDriver.Url; }
}
public void Close()
{
webDriver.Quit();
}
public IWebDriver getDriver
{
get { return webDriver; }
}
}
class Assert_Demo_1
{
Browser_ops brow = new Browser_ops();
String test_url = "https://www.lambdatest.com/";
[SetUp]
public void start_Browser()
{
brow.Init_Browser();
}
[Test]
public void test_asserturl()
{
brow.Goto(test_url);
System.Threading.Thread.Sleep(4000);
String actual_url = brow.Geturl;
Console.WriteLine("url " + actual_url);
// Raise an assert if the URL's do not match
Assert.That(actual_url, Is.EqualTo(test_url));
Console.WriteLine("Test Passed");
/* Perform wait to check the output */
System.Threading.Thread.Sleep(2000);
}
[TearDown]
public void close_Browser()
{
brow.Close();
}
}
}
voir brutEqual_To_Constraint.cs hébergé avec ❤ par GitHub
Dans le code ci-dessus, nous avons fourni deux paramètres dans le Assert.That méthode, qui sont un résultat attendu et EqualTo contrainte. L’URL réelle est comparée à l’URL de test (c’est-à-dire https://www.lambdatest.com/).
Assert.That(actual_url, Is.EqualTo(test_url));Une erreur d’assertion sera levée si les valeurs ne correspondent pas, et l’exécution du programme se terminera à cette même ligne, c’est-à-dire l’instruction d’assertion elle-même.
b. Pas égal à. Comme le nom le suggère, NoEqualTo fait le contraire de EqualTo. Il est utilisé pour vérifier si le résultat réel n’est pas le même que le résultat attendu. L’assertion sera levée si les résultats correspondent.
Syntaxe:
Is.Not.EqualTo( object expected )Voici un exemple de test d’automatisation Selenium qui démontre l’utilisation de Not.EqualTo contrainte. L’implémentation reste la même que dans l’exemple précédent, sauf que la vérification est maintenant faite pour l’inégalité.
Nom de fichier : 2_Equal_To_Constraint.cs
using NUnit.Framework;
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Firefox;
using OpenQA.Selenium.IE;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Assert_Demo
{
public class Browser_ops
{
IWebDriver webDriver;
public void Init_Browser()
{
webDriver = new ChromeDriver();
webDriver.Manage().Window.Maximize();
}
public string Title
{
get { return webDriver.Title; }
}
public void Goto(string url)
{
webDriver.Url = url;
}
public string Geturl
{
get { return webDriver.Url; }
}
public void Close()
{
webDriver.Quit();
}
public IWebDriver getDriver
{
get { return webDriver; }
}
}
class Assert_Demo_1
{
Browser_ops brow = new Browser_ops();
String test_url = "https://www.lambdatest.com";
[SetUp]
public void start_Browser()
{
brow.Init_Browser();
}
[Test]
public void test_asserturl()
{
brow.Goto(test_url);
System.Threading.Thread.Sleep(4000);
String actual_url = brow.Geturl;
Console.WriteLine("url " + actual_url);
// Raise an assert if the URL's match
// The URL on which testing is done is "https://www.lambdatest.com"
// Whereas the get URL will return "https://www.lambdatest.com/"
// Hence the above test will pass
Assert.That(actual_url, Is.Not.EqualTo(test_url));
Console.WriteLine("Test Passed");
/* Perform wait to check the output */
System.Threading.Thread.Sleep(2000);
}
[TearDown]
public void close_Browser()
{
brow.Close();
}
}
}
voir brutFileName – 2_Equal_To_Constraint.cs hébergé avec ❤ par GitHub
Dans le code ci-dessus, nous avons fourni deux paramètres dans le Assert.That méthode, qui est un résultat attendu et Not.EqualTo contrainte. L’URL réelle est comparée à l’URL de test (c’est-à-dire https://www.lambdatest.com). Bien que les URL soient les mêmes, la commande driver.Url renverra https://www.lambdatest.com/, qui ne correspond pas à l’URL de test ; par conséquent, le test réussit et assert n’est pas déclenché.
2. Contraintes de comparaison
Cette catégorie de contrainte dans l’assertion NUnit est utilisée pour tester si un objet est supérieur à l’autre. Ils sont conçus de manière à pouvoir être lus dans un ordre mathématique. L’opération de comparaison peut être pour l’égalité GreaterThan (ou GreaterThanOrEqualTo), LessThan (ou LessThanOrEqualTo), ou vérifier si le résultat se situe dans une plage particulière (InRange).
Sauf pour le InRange contrainte, toutes les autres contraintes de comparaison peuvent être utilisées avec Not, c’est à dire NotGreaterThan/NotLessThan/etc.
une. Plus grand que. Il permet de vérifier si le résultat est supérieur à celui fourni dans le GreaterThan contrainte. Cette contrainte peut être utilisée avec des valeurs d’entrée de types de données comme entier, flottant, double, long, etc.
Syntaxe:
Is.GreaterThan( object expected )Exemple:
Assert.That(arg1, Is.Greater.Than(arg2));Pour démontrer l’utilisation de l’assertion Nunit en utilisant Greater.Than contrainte, nous prenons un exemple simplifié où Assert est augmentée si la valeur réelle est supérieure à la valeur…