C# Unit Testing (Comment ça fonctionne pour les développeurs)

Créer un projet de test unitaire

Pour commencer avec les tests unitaires en C#, vous devrez configurer l'un des projets de test unitaire dans Visual Studio. Visual Studio fournit un cadre de tests unitaires intégré, rendant le démarrage simple. Lorsque vous créez un nouveau projet, sélectionnez le modèle "Projet de test unitaire" sous la catégorie C#. Ce modèle configure tout ce dont vous avez besoin pour créer des tests unitaires et les exécuter efficacement.

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;

namespace Unit_Test_Project_Example
{
    // A simple calculator class with an Add method
    public class Calculator
    {
        public int Add(int a, int b)
        {
            return a + b;
        }
    }

    // A test class to validate the functionality of the Calculator class
    [TestClass]
    public class CalculatorTests
    {
        // A test method to check if the Add method in Calculator returns the correct sum
        [TestMethod]
        public void Add_ShouldReturnCorrectSum()
        {
            // Arrange
            var calculator = new Calculator();

            // Act
            var result = calculator.Add(2, 2);

            // Assert
            Assert.AreEqual(4, result);
        }
    }
}

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;

namespace Unit_Test_Project_Example
{
    // A simple calculator class with an Add method
    public class Calculator
    {
        public int Add(int a, int b)
        {
            return a + b;
        }
    }

    // A test class to validate the functionality of the Calculator class
    [TestClass]
    public class CalculatorTests
    {
        // A test method to check if the Add method in Calculator returns the correct sum
        [TestMethod]
        public void Add_ShouldReturnCorrectSum()
        {
            // Arrange
            var calculator = new Calculator();

            // Act
            var result = calculator.Add(2, 2);

            // Assert
            Assert.AreEqual(4, result);
        }
    }
}

Imports Microsoft.VisualStudio.TestTools.UnitTesting
Imports System

Namespace Unit_Test_Project_Example
	' A simple calculator class with an Add method
	Public Class Calculator
		Public Function Add(ByVal a As Integer, ByVal b As Integer) As Integer
			Return a + b
		End Function
	End Class

	' A test class to validate the functionality of the Calculator class
	<TestClass>
	Public Class CalculatorTests
		' A test method to check if the Add method in Calculator returns the correct sum
		<TestMethod>
		Public Sub Add_ShouldReturnCorrectSum()
			' Arrange
			Dim calculator As New Calculator()

			' Act
			Dim result = calculator.Add(2, 2)

			' Assert
			Assert.AreEqual(4, result)
		End Sub
	End Class
End Namespace

Comprendre les méthodes de test et les classes de test

Dans un projet de test unitaire, vous organisez les tests en classes et méthodes. Une classe de test représente une collection de méthodes de test unitaire qui devraient être exécutées ensemble. Chaque méthode de test unitaire, décorée avec l'attribut [TestMethod], contient la logique pour tester une fonction spécifique de votre code. La classe de test elle-même est marquée avec l'attribut [TestClass], signalant au cadre de test qu'elle contient des tests à exécuter.

Utiliser l'Explorateur de tests dans Visual Studio

La fenêtre Explorateur de tests de Visual Studio est votre centre principal pour exécuter et gérer toutes les méthodes de test. Vous pouvez exécuter tous les tests, une sélection de tests ou des tests individuels. Après l'exécution des tests, l'Explorateur de tests fournit un résumé détaillé des tests réussis et échoués, vous permettant d'identifier et de résoudre rapidement les problèmes.

Interpréter les résultats des tests

• Tests réussis : Ces tests se sont déroulés avec succès, indiquant que le code testé se comporte comme prévu dans les conditions spécifiées.
• Tests échoués : ceux-ci indiquent un écart entre les résultats attendus et les résultats réels, signalant des bogues potentiels ou des malentendus dans les exigences ou le code de test.

Il est essentiel d'examiner rapidement les tests échoués, car ils peuvent signaler des problèmes précoces dans votre code.

Organiser les tests de manière efficace

Une bonne organisation est la clé pour maintenir une grande suite de tests. Regroupez vos tests de manière logique par la fonctionnalité qu'ils couvrent. Utilisez des noms descriptifs pour vos méthodes et classes de test pour indiquer ce que chaque test vérifie. Cette approche facilite la recherche et la compréhension des tests plus tard, surtout à mesure que votre suite de tests grandit.

Simuler et injection de dépendance

Souvent, le code que vous testez interagit avec des ressources externes ou d'autres parties de votre application. Dans de tels cas, utilisez des cadres de simulation comme Moq ou NSubstitute pour créer des objets simulés. Ces substituts imitent le comportement des objets réels, vous permettant de tester votre code en isolation. L'injection de dépendance rend votre code plus testable, car elle vous permet de remplacer les dépendances réelles par des simulacres ou des talons pendant les tests.

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;

// A sample test class demonstrating the use of mocks
[TestClass]
public class ProductServiceTests
{
    // A test method to verify the GetProductById method of ProductService
    [TestMethod]
    public void GetProductById_ShouldReturnCorrectProduct()
    {
        // Arrange
        var mockRepository = new Mock<IProductRepository>();
        mockRepository.Setup(x => x.FindById(1)).Returns(new Product { Id = 1, Name = "Laptop" });

        ProductService productService = new ProductService(mockRepository.Object);

        // Act
        Product result = productService.GetProductById(1);

        // Assert
        Assert.IsNotNull(result);
        Assert.AreEqual("Laptop", result.Name);
    }
}

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;

// A sample test class demonstrating the use of mocks
[TestClass]
public class ProductServiceTests
{
    // A test method to verify the GetProductById method of ProductService
    [TestMethod]
    public void GetProductById_ShouldReturnCorrectProduct()
    {
        // Arrange
        var mockRepository = new Mock<IProductRepository>();
        mockRepository.Setup(x => x.FindById(1)).Returns(new Product { Id = 1, Name = "Laptop" });

        ProductService productService = new ProductService(mockRepository.Object);

        // Act
        Product result = productService.GetProductById(1);

        // Assert
        Assert.IsNotNull(result);
        Assert.AreEqual("Laptop", result.Name);
    }
}

Imports Microsoft.VisualStudio.TestTools.UnitTesting
Imports Moq

' A sample test class demonstrating the use of mocks
<TestClass>
Public Class ProductServiceTests
	' A test method to verify the GetProductById method of ProductService
	<TestMethod>
	Public Sub GetProductById_ShouldReturnCorrectProduct()
		' Arrange
		Dim mockRepository = New Mock(Of IProductRepository)()
		mockRepository.Setup(Function(x) x.FindById(1)).Returns(New Product With {
			.Id = 1,
			.Name = "Laptop"
		})

		Dim productService As New ProductService(mockRepository.Object)

		' Act
		Dim result As Product = productService.GetProductById(1)

		' Assert
		Assert.IsNotNull(result)
		Assert.AreEqual("Laptop", result.Name)
	End Sub
End Class

Utiliser des tests basés sur les données

Les tests basés sur les données vous permettent d'exécuter la même méthode de test plusieurs fois avec différentes données d'entrée. Cette technique est particulièrement utile pour tester une large gamme d'entrées et de scénarios sans écrire plusieurs méthodes de test. Visual Studio prend en charge les tests basés sur les données en vous permettant de spécifier vos données de test à partir de diverses sources, telles que des données en ligne, des fichiers CSV ou des bases de données.

Comprendre et utiliser les assertions efficacement

Les assertions sont le cœur de vos méthodes de test, car elles valident les résultats de vos tests. Comprenez la gamme de méthodes d'assertion disponibles dans votre cadre de test et utilisez-les de manière appropriée pour vérifier les valeurs attendues, les exceptions ou les conditions. Utiliser la bonne assertion peut rendre vos tests plus clairs et plus robustes.

Intégration continue et automatisation des tests

Intégrez vos tests unitaires dans votre pipeline d'intégration continue (CI). Cela garantit que les tests sont automatiquement exécutés chaque fois que des modifications sont apportées à la base de code, aidant à détecter et à corriger les problèmes tôt. L'automatisation facilite également l'exécution fréquente et cohérente des tests, ce qui est crucial pour maintenir une base de code saine.

Synchroniser les tests et le code de production

Vos tests unitaires ne sont bons qu'autant que leur alignement avec le code de production. Assurez-vous que toutes les modifications de la fonctionnalité sont reflétées dans les tests unitaires correspondants. Cette pratique empêche les tests obsolètes de réussir incorrectement et garantit que votre suite de tests représente avec précision l'état de votre application.

Apprendre des tests échoués

Lorsqu'un test échoue, c'est une opportunité d'apprendre et de s'améliorer. Un test échoué peut révéler des comportements inattendus, des hypothèses incorrectes ou des zones de votre code qui sont plus complexes et sujettes aux erreurs que nécessaire. Analysez soigneusement les tests échoués pour comprendre leurs causes sous-jacentes et utilisez ces informations pour améliorer à la fois vos tests et votre code de production.

Exemple de code

Voici un exemple de la manière dont vous pourriez utiliser IronPDF dans un scénario de test unitaire C#. Supposons que vous vouliez tester une fonction qui génère un PDF à partir du contenu HTML. Vous pourriez utiliser IronPDF pour rendre le HTML en un PDF et ensuite vérifier l'existence ou le contenu du PDF dans le cadre de votre test :

using IronPdf;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.IO;

// A sample test class to verify PDF generation
[TestClass]
public class PdfGenerationTests
{
    // A test method to verify HTML to PDF generation using IronPDF
    [TestMethod]
    public void TestHtmlToPdfGeneration()
    {
        IronPdf.License.LicenseKey = "License-Key"; // Set your IronPDF license key

        var renderer = new ChromePdfRenderer();

        // Render HTML to a PDF
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, world!</h1>");

        string filePath = Path.Combine(Path.GetTempPath(), "test.pdf");

        // Save the generated PDF to a file
        pdf.SaveAs(filePath);

        // Assert the PDF file was created successfully
        Assert.IsTrue(File.Exists(filePath), "The generated PDF does not exist.");

        // Additional assertions to verify the PDF content could be added here
        // Clean up generated file
        File.Delete(filePath);
    }
}

using IronPdf;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.IO;

// A sample test class to verify PDF generation
[TestClass]
public class PdfGenerationTests
{
    // A test method to verify HTML to PDF generation using IronPDF
    [TestMethod]
    public void TestHtmlToPdfGeneration()
    {
        IronPdf.License.LicenseKey = "License-Key"; // Set your IronPDF license key

        var renderer = new ChromePdfRenderer();

        // Render HTML to a PDF
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, world!</h1>");

        string filePath = Path.Combine(Path.GetTempPath(), "test.pdf");

        // Save the generated PDF to a file
        pdf.SaveAs(filePath);

        // Assert the PDF file was created successfully
        Assert.IsTrue(File.Exists(filePath), "The generated PDF does not exist.");

        // Additional assertions to verify the PDF content could be added here
        // Clean up generated file
        File.Delete(filePath);
    }
}

Imports IronPdf
Imports Microsoft.VisualStudio.TestTools.UnitTesting
Imports System
Imports System.IO

' A sample test class to verify PDF generation
<TestClass>
Public Class PdfGenerationTests
	' A test method to verify HTML to PDF generation using IronPDF
	<TestMethod>
	Public Sub TestHtmlToPdfGeneration()
		IronPdf.License.LicenseKey = "License-Key" ' Set your IronPDF license key

		Dim renderer = New ChromePdfRenderer()

		' Render HTML to a PDF
		Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello, world!</h1>")

		Dim filePath As String = Path.Combine(Path.GetTempPath(), "test.pdf")

		' Save the generated PDF to a file
		pdf.SaveAs(filePath)

		' Assert the PDF file was created successfully
		Assert.IsTrue(File.Exists(filePath), "The generated PDF does not exist.")

		' Additional assertions to verify the PDF content could be added here
		' Clean up generated file
		File.Delete(filePath)
	End Sub
End Class

Cet exemple démontre un simple test unitaire qui utilise IronPDF pour générer un PDF à partir d'une chaîne HTML, le sauvegarder dans un fichier temporaire, puis vérifier l'existence du fichier.