Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. AutoFixture C#
.NET AIDE

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

Curtis Chau
Curtis Chau
Mis à jour:

AutoFixture is an open-source library for .NET destinée à minimiser la phase ‘Arrange’ de l'écriture de tests unitaires, améliorant ainsi la gestion des tests. Son objectif principal est de permettre aux développeurs de se concentrer sur ce qu'ils testent, plutôt que sur le processus de configuration, en vous permettant de créer des graphes d'objets avec des données de test. Cet article explore comment AutoFixture peut être utilisé pour faciliter le développement piloté par les tests grâce à une génération de données de test efficace.

AutoFixture est une bibliothèque puissante en C# conçue pour rationaliser le processus de création de données de test pour les tests unitaires. Il aide les développeurs à éviter d'écrire du code de configuration répétitif en générant automatiquement des données pour les cas de test. Dans les tests unitaires, AutoFixture fournit une approche simplifiée pour générer des données de test, assurant que chaque test unitaire est exécuté avec des entrées variées et réalistes. AutoFixture rend les tests en C# plus efficaces en générant automatiquement des données de test, réduisant le besoin de configurations manuelles.

AutoFixture C# (Comment cela fonctionne pour les développeurs): Figure 1 - AutoFixture

Installer et configurer AutoFixture

AutoFixture est disponible en tant que package NuGet et peut être installé en utilisant la console du gestionnaire de packages NuGet ou l'ajout de package .NET dans l'interface utilisateur du gestionnaire de packages NuGet de Visual Studio.

Install-Package AutoFixture

NuGet téléchargera et installera la dernière version de AutoFixture et ses dépendances dans votre projet.

Exemple de création de données de test pour une classe

Supposons que nous ayons une classe employé simple avec des propriétés telles que FirstName, LastName et Age. Au lieu de créer manuellement des instances de cette classe dans nos tests unitaires, nous pouvons tirer parti de AutoFixture pour générer des données aléatoires pour nous.

public class Employee
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }

    public Employee(string firstName, string lastName, int age)
    {
        FirstName = firstName;
        LastName = lastName;
        Age = age;
    }

    public string GetFullName() => $"{FirstName} {LastName}";
}
public class Employee
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }

    public Employee(string firstName, string lastName, int age)
    {
        FirstName = firstName;
        LastName = lastName;
        Age = age;
    }

    public string GetFullName() => $"{FirstName} {LastName}";
}
Public Class Employee
	Public Property FirstName() As String
	Public Property LastName() As String
	Public Property Age() As Integer

	Public Sub New(ByVal firstName As String, ByVal lastName As String, ByVal age As Integer)
		Me.FirstName = firstName
		Me.LastName = lastName
		Me.Age = age
	End Sub

	Public Function GetFullName() As String
		Return $"{FirstName} {LastName}"
	End Function
End Class
$vbLabelText   $csharpLabel

Description du code

La classe Employee encapsule les détails essentiels d'un employé, y compris leur prénom, nom et âge, représentés par les propriétés FirstName, LastName et Age respectivement. Son constructeur facilite l'instanciation d'un objet employé en acceptant ces détails en tant que paramètres et en les assignant aux propriétés correspondantes. De plus, la méthode GetFullName concatène le prénom et le nom de l'employé, renvoyant le nom complet sous forme de chaîne.

Configurer le code pour notre scénario de test

Ensuite, nous créerons une classe de test pour tester la classe Employee :

using AutoFixture;

public class EmployeeTests
{
    private readonly IFixture _fixture;

    public EmployeeTests()
    {
        // Using AutoFixture's Fixture to create test data
        _fixture = new Fixture();
    }
}
using AutoFixture;

public class EmployeeTests
{
    private readonly IFixture _fixture;

    public EmployeeTests()
    {
        // Using AutoFixture's Fixture to create test data
        _fixture = new Fixture();
    }
}
Imports AutoFixture

Public Class EmployeeTests
	Private ReadOnly _fixture As IFixture

	Public Sub New()
		' Using AutoFixture's Fixture to create test data
		_fixture = New Fixture()
	End Sub
End Class
$vbLabelText   $csharpLabel

Description du code

Ce fragment de code intègre AutoFixture dans les tests unitaires pour la classe Employee. En important l'espace de noms AutoFixture, les développeurs accèdent à la fonctionnalité de génération de données. Le champ _fixture, initialisé avec une nouvelle instance de Fixture, rationalise la création de données de test. Cette configuration améliore l'efficacité et la fiabilité des tests pour une couverture complète de la classe Employee.

Exemple 1 : Validation des valeurs des objets de test Employee

[Fact]
public void Employee_ShouldHaveValidValues()
{
    // Arrange
    var firstName = _fixture.Create<string>();
    var lastName = _fixture.Create<string>();
    var age = _fixture.Create<int>();

    // Act
    var employee = new Employee(firstName, lastName, age);

    // Assert
    Assert.Equal(firstName, employee.FirstName);
    Assert.Equal(lastName, employee.LastName);
    Assert.Equal(age, employee.Age);
}
[Fact]
public void Employee_ShouldHaveValidValues()
{
    // Arrange
    var firstName = _fixture.Create<string>();
    var lastName = _fixture.Create<string>();
    var age = _fixture.Create<int>();

    // Act
    var employee = new Employee(firstName, lastName, age);

    // Assert
    Assert.Equal(firstName, employee.FirstName);
    Assert.Equal(lastName, employee.LastName);
    Assert.Equal(age, employee.Age);
}
<Fact>
Public Sub Employee_ShouldHaveValidValues()
	' Arrange
	Dim firstName = _fixture.Create(Of String)()
	Dim lastName = _fixture.Create(Of String)()
	Dim age = _fixture.Create(Of Integer)()

	' Act
	Dim employee As New Employee(firstName, lastName, age)

	' Assert
	Assert.Equal(firstName, employee.FirstName)
	Assert.Equal(lastName, employee.LastName)
	Assert.Equal(age, employee.Age)
End Sub
$vbLabelText   $csharpLabel

Description du code

La méthode de test Employee_ShouldHaveValidValues valide que la classe Employee initialise correctement ses propriétés avec les valeurs fournies. En utilisant une configuration de test pour générer des données aléatoires pour les propriétés FirstName, LastName et Age, le test crée une instance de Employee. Il vérifie ensuite que les propriétés FirstName, LastName et Age de l'objet Employee correspondent aux valeurs générées, s'assurant que le constructeur assigne ces propriétés correctement.

Exemple 2 : Validation d'Employee lorsque le constructeur est invoqué

[Fact]
public void CreateEmployee_ValidData_ReturnsEmployeeObject()
{
    // Arrange
    var employee = _fixture.Create<Employee>();

    // Act 
    // Assert
    Assert.NotNull(employee);
    Assert.False(string.IsNullOrEmpty(employee.FirstName));
    Assert.NotNull(employee.LastName);
    Assert.True(employee.Age > 0);
}
[Fact]
public void CreateEmployee_ValidData_ReturnsEmployeeObject()
{
    // Arrange
    var employee = _fixture.Create<Employee>();

    // Act 
    // Assert
    Assert.NotNull(employee);
    Assert.False(string.IsNullOrEmpty(employee.FirstName));
    Assert.NotNull(employee.LastName);
    Assert.True(employee.Age > 0);
}
<Fact>
Public Sub CreateEmployee_ValidData_ReturnsEmployeeObject()
	' Arrange
	Dim employee = _fixture.Create(Of Employee)()

	' Act 
	' Assert
	Assert.NotNull(employee)
	Assert.False(String.IsNullOrEmpty(employee.FirstName))
	Assert.NotNull(employee.LastName)
	Assert.True(employee.Age > 0)
End Sub
$vbLabelText   $csharpLabel

Description du code

Cette méthode de test inclut des assertions de test qui valident si les propriétés d'un objet Employee correspondent à des valeurs générées aléatoirement. Elle vérifie si les propriétés du type string FirstName et LastName, et int Age sont correctement définies et valides. Toute assertion échouée signale une discordance entre les valeurs attendues et les valeurs aléatoires générées pour les détails de l'employé.

AutoFixture C# (Comment cela fonctionne pour les développeurs): Figure 2 - Test unitaire de données d'employés valides

Introducing IronPDF

IronPDF C# PDF Library is a robust C# PDF library developed by Iron Software that facilitates the reading of PDF text and the création de documents PDF utilisant HTML. Cet outil polyvalent permet la conversion de documents faciles à formater, avec des informations de style, en PDF de haute qualité. Avec IronPDF, générer des PDFs à partir de texte HTML est un processus transparent, permettant aux utilisateurs de tirer du contenu HTML depuis des URL et de le transformer en fichiers PDF bien structurés. Cette capacité fait de IronPDF un outil essentiel pour les développeurs cherchant à automatiser et simplifier la création de documents PDF professionnels directement à partir de contenu web.

AutoFixture C# (Comment cela fonctionne pour les développeurs): Figure 3 - IronPDF

Installer IronPDF

Ouvrez la console du gestionnaire de packages NuGet, et exécutez la commande suivante:

Install-Package IronPdf

Exemple de code utilisant les fonctionnalités de AutoFixture avec IronPDF

Voici un exemple démontrant l'utilisation de AutoFixture aux côtés de IronPDF pour générer un PDF des données des employés :

using DemoAutofixture;
using IronPdf;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

public class EmployeePdfGenerator
{
    private readonly Fixture _fixture;

    public EmployeePdfGenerator()
    {
        _fixture = new Fixture();
    }

    public List<Employee> GenerateEmployees(int count)
    {
        return _fixture.CreateMany<Employee>(count).ToList();
    }

    public void GeneratePdf(List<Employee> employees, string filePath)
    {
        IronPdf.License.LicenseKey = "Your-License-Key-Here";
        var renderer = new ChromePdfRenderer();
        string htmlContent = GenerateHtml(employees);

        try
        {
            renderer.RenderHtmlAsPdf(htmlContent).SaveAs(filePath);
            Console.WriteLine("PDF Created Successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error generating PDF: {ex.Message}");
        }
    }

    private string GenerateHtml(List<Employee> employees)
    {
        StringBuilder htmlBuilder = new StringBuilder();
        htmlBuilder.Append("<!DOCTYPE html><html><head><title>Employee List</title></head><body><h1>Employee List</h1><ul>");

        foreach (var employee in employees)
        {
            htmlBuilder.Append($"<li>{employee.GetFullName()} - Age: {employee.Age}</li>");
        }

        htmlBuilder.Append("</ul></body></html>");
        return htmlBuilder.ToString();
    }
}
using DemoAutofixture;
using IronPdf;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

public class EmployeePdfGenerator
{
    private readonly Fixture _fixture;

    public EmployeePdfGenerator()
    {
        _fixture = new Fixture();
    }

    public List<Employee> GenerateEmployees(int count)
    {
        return _fixture.CreateMany<Employee>(count).ToList();
    }

    public void GeneratePdf(List<Employee> employees, string filePath)
    {
        IronPdf.License.LicenseKey = "Your-License-Key-Here";
        var renderer = new ChromePdfRenderer();
        string htmlContent = GenerateHtml(employees);

        try
        {
            renderer.RenderHtmlAsPdf(htmlContent).SaveAs(filePath);
            Console.WriteLine("PDF Created Successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error generating PDF: {ex.Message}");
        }
    }

    private string GenerateHtml(List<Employee> employees)
    {
        StringBuilder htmlBuilder = new StringBuilder();
        htmlBuilder.Append("<!DOCTYPE html><html><head><title>Employee List</title></head><body><h1>Employee List</h1><ul>");

        foreach (var employee in employees)
        {
            htmlBuilder.Append($"<li>{employee.GetFullName()} - Age: {employee.Age}</li>");
        }

        htmlBuilder.Append("</ul></body></html>");
        return htmlBuilder.ToString();
    }
}
Imports DemoAutofixture
Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports System.Text

Public Class EmployeePdfGenerator
	Private ReadOnly _fixture As Fixture

	Public Sub New()
		_fixture = New Fixture()
	End Sub

	Public Function GenerateEmployees(ByVal count As Integer) As List(Of Employee)
		Return _fixture.CreateMany(Of Employee)(count).ToList()
	End Function

	Public Sub GeneratePdf(ByVal employees As List(Of Employee), ByVal filePath As String)
		IronPdf.License.LicenseKey = "Your-License-Key-Here"
		Dim renderer = New ChromePdfRenderer()
		Dim htmlContent As String = GenerateHtml(employees)

		Try
			renderer.RenderHtmlAsPdf(htmlContent).SaveAs(filePath)
			Console.WriteLine("PDF Created Successfully!")
		Catch ex As Exception
			Console.WriteLine($"Error generating PDF: {ex.Message}")
		End Try
	End Sub

	Private Function GenerateHtml(ByVal employees As List(Of Employee)) As String
		Dim htmlBuilder As New StringBuilder()
		htmlBuilder.Append("<!DOCTYPE html><html><head><title>Employee List</title></head><body><h1>Employee List</h1><ul>")

		For Each employee In employees
			htmlBuilder.Append($"<li>{employee.GetFullName()} - Age: {employee.Age}</li>")
		Next employee

		htmlBuilder.Append("</ul></body></html>")
		Return htmlBuilder.ToString()
	End Function
End Class
$vbLabelText   $csharpLabel

Pour utiliser cette classe, vous instancieriez EmployeePdfGenerator, généreriez une liste d'employés, et appelleriez ensuite GeneratePdf :

List<Employee> employees = new()
{
    new Employee("John", "Smith", 32),
    new Employee("Emily", "Davis", 18),
    new Employee("David", "Brown", 24),
    new Employee("Jane", "Doe", 16),
    new Employee("Michael", "Johnson", 49),
};

EmployeePdfGenerator pdfGenerator = new();
pdfGenerator.GeneratePdf(employees, "EmployeeList.pdf");
List<Employee> employees = new()
{
    new Employee("John", "Smith", 32),
    new Employee("Emily", "Davis", 18),
    new Employee("David", "Brown", 24),
    new Employee("Jane", "Doe", 16),
    new Employee("Michael", "Johnson", 49),
};

EmployeePdfGenerator pdfGenerator = new();
pdfGenerator.GeneratePdf(employees, "EmployeeList.pdf");
Dim employees As New List(Of Employee)() From {
	New Employee("John", "Smith", 32),
	New Employee("Emily", "Davis", 18),
	New Employee("David", "Brown", 24),
	New Employee("Jane", "Doe", 16),
	New Employee("Michael", "Johnson", 49)
}

Dim pdfGenerator As New EmployeePdfGenerator()
pdfGenerator.GeneratePdf(employees, "EmployeeList.pdf")
$vbLabelText   $csharpLabel

AutoFixture C# (Comment cela fonctionne pour les développeurs): Figure 4 - Autofixture avec IronPDF Output

Description du code

Le code C# fourni utilise la bibliothèque IronPDF pour générer un document PDF listant les employés et leurs âges. Il définit une classe EmployeePdfGenerator qui inclut la méthode GeneratePdf, qui prend une liste d'objets Employee et un chemin de fichier. En interne, il construit du contenu HTML via la méthode GenerateHtml, puis utilise la classe HtmlToPdf de IronPDF pour rendre cet HTML comme un PDF, sauvegardé au chemin de fichier spécifié. Les améliorations incluent l'utilisation de StringBuilder pour la génération HTML et l'ajout d'une gestion d'erreurs de base pour la génération de PDF et la sauvegarde de fichiers.

Écriture d'une méthode de test

Dans la configuration ci-dessous, AutoFixture est utilisé pour créer des instances de la classe Employee, permettant la génération de données aléatoires pour les tests. IronPDF est employé pour convertir facilement le contenu HTML, y compris les informations de l'employé, en format PDF. La classe EmployeePdfGenerator orchestre ces processus, gérant à la fois la génération de données et la conversion en PDF de manière efficace. Pendant ce temps, la classe de test EmployeePdfGeneratorTests XUnit garantit le bon fonctionnement de la génération de PDF par des tests rigoureux. Cette approche intégrée simplifie la génération et la documentation des données des employés, assurant la robustesse et la fiabilité du processus de génération de PDF.

using System.IO;
using Xunit;

public class EmployeePdfGeneratorTests
{
    [Fact]
    public void GeneratePdf_GeneratesPdfFile()
    {
        // Arrange
        var generator = new EmployeePdfGenerator();
        var employees = generator.GenerateEmployees(5);
        string filePath = "EmployeeList.pdf";

        // Act
        generator.GeneratePdf(employees, filePath);

        // Assert
        Assert.True(File.Exists(filePath));
    }
}
using System.IO;
using Xunit;

public class EmployeePdfGeneratorTests
{
    [Fact]
    public void GeneratePdf_GeneratesPdfFile()
    {
        // Arrange
        var generator = new EmployeePdfGenerator();
        var employees = generator.GenerateEmployees(5);
        string filePath = "EmployeeList.pdf";

        // Act
        generator.GeneratePdf(employees, filePath);

        // Assert
        Assert.True(File.Exists(filePath));
    }
}
Imports System.IO
Imports Xunit

Public Class EmployeePdfGeneratorTests
	<Fact>
	Public Sub GeneratePdf_GeneratesPdfFile()
		' Arrange
		Dim generator = New EmployeePdfGenerator()
		Dim employees = generator.GenerateEmployees(5)
		Dim filePath As String = "EmployeeList.pdf"

		' Act
		generator.GeneratePdf(employees, filePath)

		' Assert
		Assert.True(File.Exists(filePath))
	End Sub
End Class
$vbLabelText   $csharpLabel

Ici, la classe EmployeePdfGeneratorTests contient un cas de test qui valide la création d'un fichier PDF au chemin de fichier spécifié, assurant que la méthode GeneratePdf fonctionne correctement.

AutoFixture C# (Comment cela fonctionne pour les développeurs): Figure 5 - AutoFixture C#

Conclusion

AutoFixture simplifie la phase ‘Arrange’ de l'écriture de tests unitaires en .NET, offrant aux développeurs un moyen de se concentrer sur les cas de test plutôt que sur les complexités de configuration. Il simplifie le processus de test unitaire, assurant des entrées variées et réalistes en générant automatiquement des données de test. En conjonction avec les Informations de Licence IronPDF, il fournit une combinaison puissante pour une utilisation continue et un support.

Questions Fréquemment Posées

Comment puis-je générer des données de test en C# en utilisant AutoFixture ?

Vous pouvez utiliser AutoFixture pour générer des données de test en C# en utilisant sa classe 'Fixture'. Cette classe vous permet de créer automatiquement des instances de classes avec des données aléatoires, ce qui peut être utilisé pour configurer efficacement divers scénarios de test.

Quelles sont les étapes d'installation pour AutoFixture dans un projet .NET ?

Pour installer AutoFixture dans un projet .NET, vous pouvez utiliser la Console du Gestionnaire de Packages NuGet avec la commande Install-Package AutoFixture. Il est également disponible via l'interface utilisateur du Gestionnaire de Packages NuGet de Visual Studio, où vous pouvez rechercher AutoFixture et l'ajouter à votre projet.

Comment AutoFixture améliore-t-il le processus de tests unitaires ?

AutoFixture améliore le processus de tests unitaires en générant automatiquement des données de test réalistes et diversifiées. Cela réduit le besoin de configuration manuelle et garantit que les tests sont effectués avec une large gamme d'entrées, améliorant ainsi la couverture et la fiabilité des tests.

AutoFixture peut-il être intégré aux bibliothèques de génération de PDF en .NET ?

Oui, AutoFixture peut être intégré aux bibliothèques de génération de PDF comme IronPDF en .NET. En utilisant AutoFixture pour générer des données, vous pouvez créer des PDFs contenant un contenu dynamique, comme des données d'employés, en tirant parti des capacités d'IronPDF pour convertir du HTML en PDF.

Quel est le but de la classe 'Fixture' dans AutoFixture ?

La classe 'Fixture' dans AutoFixture est conçue pour simplifier la configuration de test en créant automatiquement des données de test. Elle génère des instances de classes avec des données aléatoires, permettant aux développeurs de se concentrer davantage sur les tests de la logique plutôt que sur la configuration manuelle des données.

Comment AutoFixture facilite le développement dirigé par les tests (TDD) ?

AutoFixture aide au développement piloté par les tests (TDD) en fournissant un moyen simple de générer des données de test, permettant aux développeurs d'écrire des tests et d'implémenter des fonctionnalités sans passer un temps excessif sur la configuration des données. Cela simplifie le processus TDD, le rendant plus efficace.

Comment puis-je automatiser la création de documents en C# en utilisant AutoFixture et des bibliothèques PDF ?

Vous pouvez automatiser la création de documents en C# en combinant AutoFixture et une bibliothèque PDF comme IronPDF. AutoFixture peut générer les données nécessaires pour le document, et IronPDF peut convertir ces données, formatées en HTML, en un document PDF de manière efficace.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit