AutoFixture ist eine Open-Source-Bibliothek für .NET, die darauf abzielt, die 'Arrange'-Phase des Schreibens von Unit-Tests zu minimieren, um so das Testmanagement zu verbessern. Ihr Hauptziel ist es, Entwicklern zu ermöglichen, sich auf das zu konzentrieren, was sie testen, anstatt auf den Einrichtungsprozess, indem sie Objektstrukturen mit Testdaten erstellen können. Dieser Artikel untersucht, wie AutoFixture verwendet werden kann, um testgetriebene Entwicklung durch effiziente Testdatengenerierung zu erleichtern.

AutoFixture ist eine leistungsstarke Bibliothek in C#, die darauf ausgelegt ist, den Prozess der Erstellung von Testdaten für Unit-Tests zu optimieren. Sie hilft Entwicklern, das Schreiben von sich wiederholendem Einrichtungscode zu vermeiden, indem automatisch Daten für Testfälle generiert werden. Im Unit-Testing bietet AutoFixture einen optimierten Ansatz zur Generierung von Testdaten, der sicherstellt, dass jeder Unit-Test mit verschiedenen und realistischen Eingaben ausgeführt wird. AutoFixture macht das Testen in C# effizienter, indem es automatisch Testdaten generiert und den Bedarf an manueller Einrichtung reduziert.

Installieren und Einrichten von AutoFixture

AutoFixture ist als NuGet-Paket verfügbar und kann mithilfe der NuGet-Paket-Manager-Konsole oder des .NET-Paket-Hinzufügens in der NuGet-Paket-Manager-Benutzeroberfläche von Visual Studio installiert werden.

Install-Package AutoFixture

NuGet lädt die neueste Version von AutoFixture und seinen Abhängigkeiten in Ihr Projekt herunter und installiert sie.

Beispiel für die Erstellung von Testdaten für eine Klasse

Angenommen, wir haben eine einfache Mitarbeiterklasse mit Eigenschaften wie FirstName, LastName und Age. Anstatt Instanzen dieser Klasse in unseren Unit-Tests manuell zu erstellen, können wir AutoFixture nutzen, um für uns zufällige Daten zu generieren.

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

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

Beschreibung des Codes

Die Employee-Klasse kapselt wesentliche Details eines Mitarbeiters, einschließlich ihres Vornamens, Nachnamens und Alters, dargestellt durch die Eigenschaften FirstName, LastName und Age. Ihr Konstruktor ermöglicht die Instanziierung eines Mitarbeiterobjekts, indem er diese Details als Parameter akzeptiert und sie den entsprechenden Eigenschaften zuweist. Zusätzlich verbindet die GetFullName-Methode den Vornamen und Nachnamen des Mitarbeiters und gibt den vollständigen Namen als Zeichenkette zurück.

Einrichten des Codes für unser Testszenario

Als Nächstes erstellen wir eine Testklasse, um die Employee-Klasse zu testen:

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

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

Beschreibung des Codes

Dieses Code-Snippet integriert AutoFixture in die Komponententests für die Employee-Klasse. Durch die Einbindung des AutoFixture-Namespaces erhalten Entwickler Zugriff auf Daten-Generierungsmöglichkeiten. Das _fixture-Feld, initialisiert mit einer neuen Instanz von Fixture, vereinfacht die Erstellung von Testdaten. Diese Einrichtung verbessert die Testeffizienz und Zuverlässigkeit für eine umfassende Abdeckung der Employee-Klasse.

Beispiel 1: Validierung der Werte von Mitarbeiter-Testfall-Objekten

[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

<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

Beschreibung des Codes

Die Testmethode Employee_ShouldHaveValidValues validiert, dass die Employee-Klasse ihre Eigenschaften korrekt mit bereitgestellten Werten initialisiert. Durch die Verwendung einer Testumgebung zur Generierung zufälliger Daten für die FirstName, LastName und Age wird in dem Test eine Employee-Instanz erstellt. Anschließend wird sichergestellt, dass die FirstName, LastName und Age-Eigenschaften des Employee-Objekts den generierten Werten entsprechen, um sicherzustellen, dass der Konstruktor diese Eigenschaften genau setzt.

Beispiel 2: Validierung des Mitarbeiters beim Aufruf des Konstruktors

[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

<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

Beschreibung des Codes

Diese Testmethode enthält Testüberprüfungen, die validieren, ob die Eigenschaften eines Employee-Objekts zufällig generierten Werten entsprechen. Es wird überprüft, ob die Typ-Eigenschaften string FirstName und LastName sowie int Age ordnungsgemäß festgelegt und gültig sind. Alle fehlgeschlagenen Zusicherungen deuten auf eine Diskrepanz zwischen den erwarteten und den zufällig generierten Werten für Mitarbeiterdetails hin.

Einführung in IronPDF

Die IronPDF C# PDF-Bibliothek ist eine robuste C#-PDF-Bibliothek, die von Iron Software entwickelt wurde und das Lesen von PDF-Texten sowie die Erstellung von PDF-Dokumenten mit HTML erleichtert. Dieses vielseitige Tool ermöglicht die Umwandlung von Dokumenten mit einfacher Formatierung und Stilinformationen in hochwertige PDFs. Mit IronPDF ist das Erstellen von PDFs aus HTML-Text ein nahtloser Prozess, der es Benutzern erlaubt, HTML-Inhalte aus URLs zu ziehen und diese in gut strukturierte PDF-Dateien zu transformieren. Diese Fähigkeit macht IronPDF zu einem unverzichtbaren Werkzeug für Entwickler, die die Erstellung von professionellen PDF-Dokumenten direkt aus Webinhalten automatisieren und optimieren möchten.

Installation von IronPDF

Öffnen Sie die NuGet-Paket-Manager-Konsole und führen Sie den folgenden Befehl aus:

Install-Package IronPdf

Codebeispiel für die Verwendung der Funktionen von AutoFixture mit IronPDF

Unten ist ein Beispiel, das zeigt, wie AutoFixture zusammen mit IronPDF verwendet wird, um ein PDF mit Mitarbeiterdaten zu generieren:

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

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

Um diese Klasse zu verwenden, würden Sie EmployeePdfGenerator instanziieren, eine Liste von Mitarbeitern generieren und dann GeneratePdf aufrufen:

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")

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")

Beschreibung des Codes

Der bereitgestellte C#-Code verwendet die IronPDF-Bibliothek, um ein PDF-Dokument zu generieren, das Mitarbeiter und deren Alter auflistet. Es definiert eine EmployeePdfGenerator-Klasse, die die Methode GeneratePdf enthält, welche eine Liste von Employee-Objekten und einen Dateipfad nimmt. Intern erstellt es HTML-Inhalte über die GenerateHtml-Methode, nutzt dann die HtmlToPdf-Klasse von IronPDF, um dieses HTML als PDF zu rendern, das am angegebenen Dateipfad gespeichert wird. Verbesserungen umfassen die Verwendung von StringBuilder für die HTML-Erstellung und das Hinzufügen grundlegender Fehlerbehandlung für die PDF-Erstellung und das Speichern von Dateien.

Schreiben einer Testmethode

In der unten stehenden Einrichtung wird AutoFixture zur Erstellung von Instanzen der Employee-Klasse verwendet und ermöglicht die Generierung zufälliger Daten für Tests. IronPDF wird verwendet, um HTML-Inhalte, einschließlich Mitarbeiterinformationen, nahtlos in PDF-Format zu konvertieren. Die EmployeePdfGenerator-Klasse orchestriert diese Prozesse und verwaltet sowohl die Datengenerierung als auch die PDF-Konvertierung effizient. Inzwischen stellt die EmployeePdfGeneratorTests XUnit-Testklasse durch rigorose Tests die ordnungsgemäße Funktionalität der PDF-Erstellung sicher. Dieser integrierte Ansatz vereinfacht die Generierung und Dokumentation von Mitarbeiterdaten und stellt Robustheit und Zuverlässigkeit im PDF-Generierungsprozess sicher.

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

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

Hier enthält die EmployeePdfGeneratorTests-Klasse einen Testfall, der die Erstellung einer PDF-Datei am angegebenen Dateipfad validiert und sicherstellt, dass die GeneratePdf-Methode korrekt funktioniert.

Abschluss

AutoFixture vereinfacht die 'Arrange'-Phase beim Schreiben von Unit-Tests in .NET und bietet den Entwicklern die Möglichkeit, sich auf Testfälle anstatt auf Einrichtungsdetails zu konzentrieren. Es optimiert den Prozess des Unit-Testings und sorgt durch die automatische Generierung von Testdaten für verschiedene und realistische Eingaben. In Verbindung mit IronPDF-Lizenzinformationen bietet es eine leistungsstarke Kombination für den kontinuierlichen Einsatz und Support.