AutoFixture ist eine Open-Source-Bibliothek für.NET die darauf abzielt, die Phase "Anordnen" beim Schreiben von Einheitstests zu minimieren und dadurch das Testmanagement zu verbessern. Sein Hauptziel ist es, Entwicklern die Möglichkeit zu geben, sich auf das Testen zu konzentrieren und nicht auf den Einrichtungsprozess, indem Sie Objektdiagramme mit Testdaten erstellen können. Dieser Artikel untersucht, wie AutoFixture verwendet werden kann, um die testgetriebene Entwicklung durch effiziente Testdatengenerierung zu erleichtern.

Einführung

AutoFixture ist eine leistungsstarke Bibliothek in C#, die entwickelt wurde, um den Prozess der Erstellung von Testdaten für Unit-Tests zu rationalisieren. Es hilft Entwicklern, das Schreiben von sich wiederholendem Setup-Code zu vermeiden, indem es automatisch Daten für Testfälle generiert. Bei Unit-Tests bietet AutoFixture einen optimierten Ansatz für die Generierung von Testdaten und stellt sicher, dass jeder Unit-Test mit unterschiedlichen und realistischen Eingaben ausgeführt wird. AutoFixture macht das Testen in C# effizienter, indem es automatisch Testdaten generiert und so den Bedarf an manueller Einrichtung reduziert.

Installieren und Einrichten von AutoFixture

AutoFixture ist als NuGet-Paket verfügbar und kann installiert werden. Dies kann über die NuGet Package Manager Console oder das .NET-Paket hinzufügen Visual Studio's NuGet Package Manager UI erfolgen.

Install-Package AutoFixture

Install-Package AutoFixture

IRON VB CONVERTER ERROR developers@ironsoftware.com

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

Beispiel Erstellen von Testdaten für eine Klasse

Angenommen, wir haben eine einfache Angestellteninstanzklasse mit Eigenschaften wie FirstName, LastName und Age. Anstatt Instanzen dieser neuen Fixture-Klasse in unseren Unit-Tests manuell zu erstellen, können wir AutoFixture nutzen, um Zufallsdaten für uns 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}";
  }

IRON VB CONVERTER ERROR developers@ironsoftware.com

Beschreibung des Codes

Die Klasse Employee kapselt nun die wesentlichen Details eines Mitarbeiters, einschließlich seines Vornamens, Nachnamens und Alters, die durch die Eigenschaften FirstName, LastName und Age dargestellt werden. Sein Konstruktor erleichtert die Instanziierung eines Mitarbeiterobjekts, indem er diese Angaben als Parameter entgegennimmt und sie den entsprechenden Eigenschaften zuweist. Darüber hinaus verknüpft die Methode GetFullName den Vornamen und den Nachnamen des Mitarbeiters und gibt den vollständigen Namen als Zeichenkette zurück.

Einrichten des Codes für unser Testszenario

Als Nächstes werden wir den Code zum Testen erstellen:

using AutoFixture;
public class EmployeeTests
{
    private readonly IFixture _fixture;
    public EmployeeTests()
    {
        _fixture = new Fixture(); // var fixture
    }
}

using AutoFixture;
public class EmployeeTests
{
    private readonly IFixture _fixture;
    public EmployeeTests()
    {
        _fixture = new Fixture(); // var fixture
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Beschreibung des Codes

Dieser Codeschnipsel integriert AutoFixture in Unit-Tests für die Klasse Employee. Durch den Import des AutoFixture-Namensraums haben Entwickler Zugriff auf die Datengenerierungsfunktionen. Das Feld _fixture, das im Konstruktor mit einer neuen Instanz von Fixture initialisiert wird, vereinfacht die Erstellung von Testdaten. Dieser Aufbau erhöht die Testeffizienz und -zuverlässigkeit für eine umfassende Abdeckung der Klasse Mitarbeiter.

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);
    }

IRON VB CONVERTER ERROR developers@ironsoftware.com

Beschreibung des Codes

Die Testmethode Employee_ShouldHaveValidValues prüft, ob die Klasse Employee ihre Eigenschaften korrekt mit den angegebenen Werten initialisiert. Mit Hilfe einer Testvorrichtung, die zufällige Daten für den Vornamen, den Nachnamen und das Alter generiert, erstellt der Test eine Employee-Instanz. Anschließend wird sichergestellt, dass die Eigenschaften FirstName, LastName und Age des Employee-Objekts mit den generierten Werten übereinstimmen und dass der Konstruktor diese Eigenschaften korrekt festlegt.

Beispiel 2: Validierung von Employee 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);
        }

IRON VB CONVERTER ERROR developers@ironsoftware.com

Beschreibung des Codes

Dieser Testcodeausschnitt enthält Testaussagen, mit denen überprüft wird, ob die Eigenschaften eines Employee-Objekts mit zufällig generierten Werten übereinstimmen. Es wird überprüft, ob die Stringtyp-Eigenschaften von string FirstName, string LastName und int Age mit den zufällig generierten Werten übereinstimmen, die den Variablen firstName, lastName und age zugewiesen wurden. Alle fehlgeschlagenen Assertions signalisieren eine Diskrepanz zwischen den erwarteten und den zufälligen Werten, die von den Mitarbeiterdetails generiert wurden.

Einführung in IronPDF

IronPDF C# PDF-Bibliothek ist eine robuste C#-PDF-Bibliothek, die von Iron Software entwickelt wurde und dielesen von PDF-Text und dieerstellung von PDF-Dokumenten mit HTML. Dieses vielseitige Werkzeug ermöglicht die Konvertierung von einfach zu formatierenden Dokumenten mit Stilinformationen in hochwertige PDF-Dateien. Mit IronPDF,erzeugung von PDFs aus HTML der Text ist ein nahtloser Prozess, der es den Benutzern ermöglicht, HTML-Inhalte aus URLs zu ziehen und sie in gut strukturierte PDF-Dateien umzuwandeln. Diese Fähigkeit macht IronPDF zu einem unverzichtbaren Werkzeug für Entwickler, die die Erstellung professioneller PDF-Dokumente direkt aus Webinhalten automatisieren und rationalisieren möchten.

Installation von IronPDF

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

Install-Package IronPdf

Install-Package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf

Code-Beispiel zur Verwendung der Funktionen von AutoFixture mit IronPDF

Wir werden zunächst eine EmployeePdfGenerator-Klasse erstellen, die die Methode zur Erzeugung von Mitarbeitern enthält.

using DemoAutofixture;
List<Employee> employees = new List<Employee>()
{
    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");
Console.WriteLine("PDF Created Successfully!");
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);
        }
        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;
List<Employee> employees = new List<Employee>()
{
    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");
Console.WriteLine("PDF Created Successfully!");
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);
        }
        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();
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Beschreibung des Codes

Der mitgelieferte C#-Code nutzt die IronPDF-Bibliothek, um ein PDF-Dokument zu erzeugen, in dem die Mitarbeiter und ihr Alter aufgeführt sind. Sie definiert eine EmployeePdfGenerator-Klasse und enthält die Methode GeneratePdf, die eine Liste von Employee-Objekten und einen Dateipfad annimmt. Intern wird der HTML-Inhalt mit der Methode GenerateHtml erstellt. Anschließend wird die Klasse HtmlToPdf von IronPDF verwendet, um diesen HTML-Inhalt als PDF-Datei zu rendern und im angegebenen Dateipfad zu speichern. Zu den Verbesserungen gehören die Verwendung von StringBuilder für die HTML-Erzeugung und das Hinzufügen einer grundlegenden Fehlerbehandlung für die PDF-Erzeugung und das Speichern von Dateien.

Schreiben einer Prüfmethode

Im folgenden Setup wird AutoFixture für die Erstellung von Instanzen der Klasse Employee verwendet, was die Generierung von zufälligen Daten für Tests ermöglicht. IronPDF wird eingesetzt, um HTML-Inhalte, einschließlich Mitarbeiterinformationen, nahtlos in das PDF-Format zu konvertieren. Die Klasse EmployeePdfGenerator steuert diese Prozesse und verwaltet sowohl die Datenerzeugung als auch die PDF-Konvertierung effizient. In der Zwischenzeit stellt die XUnit-Testklasse EmployeePdfGeneratorTests die korrekte Funktionalität der PDF-Erzeugung durch strenge Tests sicher. Dieser integrierte Ansatz vereinfacht die Generierung und Dokumentation von Mitarbeiterdaten und gewährleistet Robustheit und Zuverlässigkeit bei der PDF-Generierung.

using System;
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;
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
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 Klasse EmployeePdfGeneratorTests Testfälle für die Klasse Employee, die PDF-Dateien über den Dateipfad validiert.

Schlussfolgerung

AutoFixture vereinfacht die "Anordnungs"-Phase beim Schreiben von Unit-Tests in .NET und bietet Entwicklern die Möglichkeit, sich auf die Testfälle zu konzentrieren, anstatt auf die Feinheiten der Einrichtung. Es rationalisiert den Unit-Test-Prozess und gewährleistet vielfältige und realistische Eingaben durch die automatische Generierung von Testdaten. In Verbindung mitIronPDF-Lizenzierungsinformationen für die weitere Nutzung und Unterstützung.