Moq C# (Wie es für Entwickler funktioniert)

In der Welt der Softwareentwicklung ist das Testen ein unverzichtbarer Prozess. Es stellt sicher, dass Ihr Code wie erwartet funktioniert und hilft, Fehler zu finden, bevor sie die Produktion erreichen. Ein wichtiger Aspekt des Testens ist Mocking, und wenn es um C#-Tests geht, ist MOQ ein mächtiges Werkzeug im Arsenal eines Entwicklers. Es bietet Unterstützung für Lambda-Ausdrücke. MOQ, kurz für "Mock Object Framework for .NET", vereinfacht den Prozess der Erstellung von Mock-Objekten für Unit-Tests. In diesem Artikel werden wir uns mit MOQ in C&num beschäftigen;

Was ist MOQ?

MOQ ist ein Mocking-Framework für .NET-Anwendungen, mit dem Entwickler schnell und effizient Mock-Objekte erstellen können. Mock-Objekte sind Objekte, die das Verhalten von realen Objekten in Ihrer Anwendung simulieren und so das Isolieren und Testen bestimmter Teile Ihres Codes erleichtern. MOQ vereinfacht den Prozess der Erstellung und Arbeit mit diesen Scheinobjekten.

Hauptmerkmale von MOQ

• Fließende Schnittstelle: MOQ bietet eine fließende und aussagekräftige API für die Einrichtung von Erwartungen und Überprüfungen. Dadurch wird Ihr Testcode lesbarer und leichter zu verstehen.
• Starke Typisierung: MOQ nutzt die C#-Sprachfunktionen, um bei der Definition von Mocks und Erwartungen eine starke Typisierung und IntelliSense-Unterstützung zu bieten. Dadurch wird die Wahrscheinlichkeit von Laufzeitfehlern in Ihren Tests verringert.
• Looses Mocking: MOQ unterstützt sowohl striktes als auch loses Mocking. Mit Loose Mocking können Sie Mock-Objekte erstellen, die auf alle Methodenaufrufe reagieren, während Strict Mocking erzwingt, dass nur erwartete Methoden aufgerufen werden.
• Überprüfbares Verhalten: MOQ ermöglicht es Ihnen, zu überprüfen, ob bestimmte Methoden Ihrer Mock-Objekte mit den erwarteten Argumenten und in der richtigen Reihenfolge aufgerufen wurden.
• Rückrufe und Rückgaben: Sie können Rückrufe definieren, um benutzerdefinierten Code auszuführen, wenn eine gespottete Methode aufgerufen wird, und Rückgabewerte für gespottete Methoden angeben.

Erste Schritte mit MOQ

In diesem Tutorial werden wir untersuchen, wie MOQ, ein beliebtes Mocking-Framework für C#, verwendet werden kann, um Unit-Tests zu erleichtern. Wir werden ein Beispiel durchgehen, in dem wir ein einfaches ATM-Transaktionsszenario mit MOQ erstellen und testen, um Abhängigkeiten zu simulieren.

Erstellen Sie eine neue C#

Folgen Sie den folgenden Schritten, um ein neues Projekt zu erstellen

1. Öffnen Sie Visual Studiogehen Sie auf "Datei" > "Neu" > "Projekt..."

2. Wählen Sie eine Projektvorlage, konfigurieren Sie die Einstellungen und klicken Sie auf "Erstellen"

   

   Angenommen, Sie entwickeln Software für einen Geldautomaten (Geldautomat)und Sie müssen die Authentifizierungs- und Abhebungsfunktionen testen. Der ATM hängt von zwei Schnittstellen ab: IHostBank und IHSMModule. Wir wollen die Klasse ATMCashWithdrawal testen, die die Bargeldabhebungsfunktionalität des Geldautomaten darstellt.

   Erstellen Sie zwei Schnittstellen, IHostBank und IHSMModule, die die Abhängigkeiten des ATM-Systems darstellen. Definieren Sie relevante Methoden wie "authenticateAmount" und "validatePIN".

// IHostBank.cs
public interface IHostBank
{
    bool AuthenticateAmount(string accountNumber, int amount);
}

// IHSMModule.cs
public interface IHSMModule
{
    bool ValidatePIN(string cardNumber, int pin);
}

// IHostBank.cs
public interface IHostBank
{
    bool AuthenticateAmount(string accountNumber, int amount);
}

// IHSMModule.cs
public interface IHSMModule
{
    bool ValidatePIN(string cardNumber, int pin);
}

' IHostBank.cs
Public Interface IHostBank
	Function AuthenticateAmount(ByVal accountNumber As String, ByVal amount As Integer) As Boolean
End Interface

' IHSMModule.cs
Public Interface IHSMModule
	Function ValidatePIN(ByVal cardNumber As String, ByVal pin As Integer) As Boolean
End Interface

Erstellen Sie die Klasse "ATMCashWithdrawal", die die oben genannten Abhängigkeiten verwendet, um ATM-Operationen durchzuführen. In dieser Klasse werden Sie eine bestimmte Methode wie WithdrawAmount implementieren.

// ATMCashWithdrawal.cs
public class ATMCashWithdrawal
{
    private readonly IHSMModule hsmModule;
    private readonly IHostBank hostBank;

    public ATMCashWithdrawal(IHSMModule hsmModule, IHostBank hostBank)
    {
        this.hsmModule = hsmModule;
        this.hostBank = hostBank;
    }
// non static method
    public bool WithdrawAmount(string cardNumber, int pin, int amount)
    {
        if (!hsmModule.ValidatePIN(cardNumber, pin))
        {
            return false;
        }

        if (!hostBank.AuthenticateAmount(cardNumber, amount))
        {
            return false;
        }

        // Withdraw the specified amount and perform other operations
        return true;
    }
}

// ATMCashWithdrawal.cs
public class ATMCashWithdrawal
{
    private readonly IHSMModule hsmModule;
    private readonly IHostBank hostBank;

    public ATMCashWithdrawal(IHSMModule hsmModule, IHostBank hostBank)
    {
        this.hsmModule = hsmModule;
        this.hostBank = hostBank;
    }
// non static method
    public bool WithdrawAmount(string cardNumber, int pin, int amount)
    {
        if (!hsmModule.ValidatePIN(cardNumber, pin))
        {
            return false;
        }

        if (!hostBank.AuthenticateAmount(cardNumber, amount))
        {
            return false;
        }

        // Withdraw the specified amount and perform other operations
        return true;
    }
}

' ATMCashWithdrawal.cs
Public Class ATMCashWithdrawal
	Private ReadOnly hsmModule As IHSMModule
	Private ReadOnly hostBank As IHostBank

	Public Sub New(ByVal hsmModule As IHSMModule, ByVal hostBank As IHostBank)
		Me.hsmModule = hsmModule
		Me.hostBank = hostBank
	End Sub
' non static method
	Public Function WithdrawAmount(ByVal cardNumber As String, ByVal pin As Integer, ByVal amount As Integer) As Boolean
		If Not hsmModule.ValidatePIN(cardNumber, pin) Then
			Return False
		End If

		If Not hostBank.AuthenticateAmount(cardNumber, amount) Then
			Return False
		End If

		' Withdraw the specified amount and perform other operations
		Return True
	End Function
End Class

Unit-Test-Projekt erstellen

Erstellen wir nun Unit-Tests für die Klasse "ATMCashWithdrawal", indem wir MOQ verwenden, um die Abhängigkeiten zu spiegeln.

Erstellen Sie ein neues Unit-Test-Projekt in Ihrer Lösung und nennen Sie es "ATMSystem.Tests".

Führen Sie die folgenden Schritte aus, um ein NUnit-Testprojekt zu Ihrer Visual Studio-Lösung hinzuzufügen:

1. Klicken Sie mit der rechten Maustaste auf die Lösung: Im Solution Explorer (in der Regel auf der rechten Seite)klicken Sie mit der rechten Maustaste auf den Namen der Lösung.

2. Hinzufügen > Neues Projekt: Wählen Sie im Kontextmenü "Hinzufügen" und dann "Neues Projekt..."

3. Erstellen eines neuen Projekts: Im Dialogfeld "Neues Projekt hinzufügen" können Sie nach "NUnit" suchen, um verfügbare NUnit-Vorlagen zu finden. Wählen Sie das NUnit-Testprojekt wie unten gezeigt.

   

4. Konfigurieren Sie das Projekt: Konfigurieren Sie die Projekteinstellungen nach Bedarf, einschließlich des Projektnamens und -orts.

5. Klicken Sie auf OK: Klicken Sie auf die Schaltfläche "Erstellen" oder "OK", um das NUnit-Testprojekt zu Ihrer Lösung hinzuzufügen.

   Jetzt haben Sie ein separates NUnit-Testprojekt innerhalb Ihrer Lösung, in dem Sie Ihre Unit-Tests schreiben und verwalten können. Sie können auch Verweise auf die Projekte hinzufügen, die Sie testen möchten, und mit dem Schreiben Ihrer NUnit-Testfälle in diesem Projekt beginnen.

   Um MOQ im Testprojekt zu verwenden, müssen Sie das MOQ NuGet-Paket zu Ihrer Lösung hinzufügen. Sie können dies mit dem NuGet-Paketmanager in Visual Studio tun oder indem Sie den folgenden Befehl in der Paketmanager-Konsole ausführen:

Install-package moq

Dieser Befehl installiert das Paket und fügt dem Projekt alle erforderlichen Abhängigkeiten hinzu.

Schreiben Sie Unit-Tests mit NUnit und MOQ, um die Abhängigkeiten zu simulieren (iHostBank" und "IHSMModul) der Klasse "ATMCashWithdrawal".

using Moq;
using MOQTestProject;

namespace UnitTest
{
    public class Tests
    {
        ATMCashWithdrawal atmCash;
        [SetUp]
        public void Setup()
        {
            // Arrange
            var hsmModuleMock = new Mock<IHSMModule>();
            hsmModuleMock.Setup(h => h.ValidatePIN("123456781234", 1234)).Returns(true);

            var hostBankMock = new Mock<IHostBank>();
            hostBankMock.Setup(h => h.AuthenticateAmount("123456781234", 500)).Returns(true);
            var atmCash = new ATMCashWithdrawal(hsmModuleMock.Object, hostBankMock.Object); // Object property
        }

        [Test]
        public void WithdrawAmount_ValidTransaction_ReturnsTrue()
        {
            // Act
            bool result = atmCash.WithdrawAmount("123456781234", 1234, 500);

            // Assert
            Assert.IsTrue(result); // Verify method 
        }

        // Add more test cases for different scenarios (e.g., invalid PIN, insufficient funds, etc.)
    }
}

using Moq;
using MOQTestProject;

namespace UnitTest
{
    public class Tests
    {
        ATMCashWithdrawal atmCash;
        [SetUp]
        public void Setup()
        {
            // Arrange
            var hsmModuleMock = new Mock<IHSMModule>();
            hsmModuleMock.Setup(h => h.ValidatePIN("123456781234", 1234)).Returns(true);

            var hostBankMock = new Mock<IHostBank>();
            hostBankMock.Setup(h => h.AuthenticateAmount("123456781234", 500)).Returns(true);
            var atmCash = new ATMCashWithdrawal(hsmModuleMock.Object, hostBankMock.Object); // Object property
        }

        [Test]
        public void WithdrawAmount_ValidTransaction_ReturnsTrue()
        {
            // Act
            bool result = atmCash.WithdrawAmount("123456781234", 1234, 500);

            // Assert
            Assert.IsTrue(result); // Verify method 
        }

        // Add more test cases for different scenarios (e.g., invalid PIN, insufficient funds, etc.)
    }
}

Imports Moq
Imports MOQTestProject

Namespace UnitTest
	Public Class Tests
		Private atmCash As ATMCashWithdrawal
		<SetUp>
		Public Sub Setup()
			' Arrange
			Dim hsmModuleMock = New Mock(Of IHSMModule)()
			hsmModuleMock.Setup(Function(h) h.ValidatePIN("123456781234", 1234)).Returns(True)

			Dim hostBankMock = New Mock(Of IHostBank)()
			hostBankMock.Setup(Function(h) h.AuthenticateAmount("123456781234", 500)).Returns(True)
			Dim atmCash = New ATMCashWithdrawal(hsmModuleMock.Object, hostBankMock.Object) ' Object property
		End Sub

		<Test>
		Public Sub WithdrawAmount_ValidTransaction_ReturnsTrue()
			' Act
			Dim result As Boolean = atmCash.WithdrawAmount("123456781234", 1234, 500)

			' Assert
			Assert.IsTrue(result) ' Verify method
		End Sub

		' Add more test cases for different scenarios (e.g., invalid PIN, insufficient funds, etc.)
	End Class
End Namespace

In diesem Testcode verwenden wir MOQ, um Mock-Objekte für IHSMModule und IHostBank zu erstellen und ihr Verhalten beim Aufruf während des Tests festzulegen.

Im obigen Codebeispiel haben wir das Konzept des Mocking von Objekten mit MOQ in C# demonstriert. Wir erstellen Mock-Objekte für die Schnittstellen IHSMModule und IHostBank und simulieren ihr Verhalten während der Unit-Tests. Auf diese Weise können wir die Klasse "ATMCashWithdrawal" isolieren und gründlich testen, indem wir die Antworten dieser Mock-Objekte kontrollieren. Durch Mocking können wir sicherstellen, dass unser Code korrekt mit diesen Abhängigkeiten interagiert, wodurch unsere Tests zielgerichtet, vorhersehbar und effektiv bei der Identifizierung von Problemen innerhalb der untersuchten Codeeinheit sind. Diese Praxis verbessert die allgemeine Zuverlässigkeit und Wartbarkeit und erleichtert das Testen von Code.

Schritt 3 Durchführung der Tests

1. Erstellen Sie Ihre Lösung, um sicherzustellen, dass alles auf dem neuesten Stand ist.

2. Öffnen Sie den Test Explorer in Visual Studio (Test > Test-Explorer).

3. Klicken Sie im Test-Explorer auf die Schaltfläche "Alle ausführen", um Ihre Einheitstests auszuführen.

4. Überprüfen Sie die Testergebnisse. Sie sollten den von Ihnen geschriebenen Test sehen (withdrawAmount_ValidTransaction_ReturnsTrue`) passieren.

   

   Auf diese Weise können wir den Code, den wir testen wollen, isolieren und sicherstellen, dass er sich in verschiedenen Szenarien wie erwartet verhält, indem wir Abhängigkeiten effektiv nachbilden. Diese Praxis verbessert die Zuverlässigkeit und Wartbarkeit Ihrer Software, da sie es einfacher macht, Probleme frühzeitig im Entwicklungsprozess zu erkennen und zu beheben.

Einführung in IronPDF

IronPDF ist eine leistungsstarke C#-Bibliothek, die es Entwicklern ermöglicht, mit PDF-Dokumenten in ihren Anwendungen zu arbeiten. Es bietet eine breite Palette von Funktionen, darunter das Erstellen, Ändern und Konvertieren von PDF-Dateien aus verschiedenen Quellen wie HTML, Bildern und bestehenden PDFs. Kombiniert mit dem Konzept der Mocking-Objekte, wie es im vorherigen Tutorial besprochen wurde, kann IronPDF ein wertvolles Werkzeug für die Erzeugung und Bearbeitung von PDF-Dokumenten in Ihren Unit-Tests sein.

Das Hauptmerkmal von IronPDF ist seine HTML zu PDF funktion, um sicherzustellen, dass Layouts und Stile intakt sind. Es wandelt Webinhalte in PDF-Dateien um und eignet sich damit hervorragend für Berichte, Rechnungen und Dokumentationen. Diese Funktion unterstützt die Umwandlung von HTML-Dateien, URLs und HTML-Strings in PDFs.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Wenn Sie beispielsweise ein Projekt haben, bei dem es um die Erstellung oder Verarbeitung von PDF-Dokumenten geht, können Sie IronPDF verwenden, um PDF-Attrappen zu erstellen, die reale Szenarien nachbilden. Dies kann besonders nützlich sein, um zu testen und zu überprüfen, wie Ihr Code mit PDF-Dateien interagiert. Sie können Schein-PDFs mit bestimmten Inhalten, Layouts und Eigenschaften generieren und diese dann als Testvorrichtungen verwenden, um sicherzustellen, dass Ihr Code die gewünschten PDF-Ausgaben erzeugt oder PDF-bezogene Vorgänge korrekt verarbeitet.

MOCK-Objekte für die Generierung von PDFs erstellen

Angenommen, Sie entwickeln eine Anwendung, die Finanzberichte erstellt, und diese Berichte müssen als PDF-Dokumente gespeichert und verteilt werden. In diesem Szenario sollten Sie die PDF-Erstellung testen und sicherstellen, dass Inhalt und Formatierung korrekt sind.

Zuerst müssen wir IronPDF zu unserem Projekt hinzufügen. Schreiben Sie den folgenden Befehl in die NuGet Package Manager Console, um IronPDF zu installieren.

Install-Package IronPdf

Mit diesem Befehl werden die erforderlichen Abhängigkeiten installiert und zu unserem Projekt hinzugefügt.

Im Folgenden wird erläutert, wie IronPDF in den Unit-Test-Prozess integriert werden kann:

Erzeugen von Mock-PDFs

Mit IronPDF können Sie Schein-PDF-Dokumente mit bestimmten Inhalten und Gestaltungen erstellen, um echte Finanzberichte zu imitieren. Diese Mock-PDFs können als Testfixtures für Ihre Unit-Tests dienen, wie im folgenden Codeschnipsel gezeigt:

public class PDFGenerator
{
    public void GenerateFinancialReport(string reportData)
    {
        var renderer = new ChromePdfRenderer();
        // Generate the report HTML
        string reportHtml = GenerateReportHtml(reportData);
        PdfDocument pdfDocument = renderer.RenderHtmlAsPdf(reportHtml);
        // Save the PDF to a file or memory stream
        pdfDocument.SaveAsPdfA("FinancialReport.pdf");
    }

    private string GenerateReportHtml(string reportData)
    {
        // Generate the report HTML based on the provided data
        // (e.g., using Razor views or any HTML templating mechanism)
        // Return the HTML as a string

        return "<h1>my Report</h1>";
    }
}

public class PDFGenerator
{
    public void GenerateFinancialReport(string reportData)
    {
        var renderer = new ChromePdfRenderer();
        // Generate the report HTML
        string reportHtml = GenerateReportHtml(reportData);
        PdfDocument pdfDocument = renderer.RenderHtmlAsPdf(reportHtml);
        // Save the PDF to a file or memory stream
        pdfDocument.SaveAsPdfA("FinancialReport.pdf");
    }

    private string GenerateReportHtml(string reportData)
    {
        // Generate the report HTML based on the provided data
        // (e.g., using Razor views or any HTML templating mechanism)
        // Return the HTML as a string

        return "<h1>my Report</h1>";
    }
}

Public Class PDFGenerator
	Public Sub GenerateFinancialReport(ByVal reportData As String)
		Dim renderer = New ChromePdfRenderer()
		' Generate the report HTML
		Dim reportHtml As String = GenerateReportHtml(reportData)
		Dim pdfDocument As PdfDocument = renderer.RenderHtmlAsPdf(reportHtml)
		' Save the PDF to a file or memory stream
		pdfDocument.SaveAsPdfA("FinancialReport.pdf")
	End Sub

	Private Function GenerateReportHtml(ByVal reportData As String) As String
		' Generate the report HTML based on the provided data
		' (e.g., using Razor views or any HTML templating mechanism)
		' Return the HTML as a string

		Return "<h1>my Report</h1>"
	End Function
End Class

Unit Testing mit Mock-PDFs

Wir werden Tests für die Verwendung von IronPDF schreiben, um Mock-PDFs zu erzeugen, die verschiedene Berichtsszenarien darstellen. Anschließend vergleichen wir die von unserem Code erzeugten PDF-Dateien mit diesen Schein-PDFs, um sicherzustellen, dass Inhalt, Formatierung und Struktur den Erwartungen entsprechen.

internal class PDFGeneratorTests
{
    [Test]
    public void GenerateFinancialReport_CreatesCorrectPDF()
    {
        // Arrange
        var mock = new PDFGenerator();
        var expectedPdf = PdfDocument.FromFile("ExpectedFinancialReport.pdf"); // Load a mock PDF

        // Act
        mock.GenerateFinancialReport("Sample report data");
        var actualPdf = PdfDocument.FromFile("FinancialReport.pdf");

        // Assert
        Assert.AreEqual(actualPdf.ExtractAllText() , expectedPdf.ExtractAllText());
    }

}

internal class PDFGeneratorTests
{
    [Test]
    public void GenerateFinancialReport_CreatesCorrectPDF()
    {
        // Arrange
        var mock = new PDFGenerator();
        var expectedPdf = PdfDocument.FromFile("ExpectedFinancialReport.pdf"); // Load a mock PDF

        // Act
        mock.GenerateFinancialReport("Sample report data");
        var actualPdf = PdfDocument.FromFile("FinancialReport.pdf");

        // Assert
        Assert.AreEqual(actualPdf.ExtractAllText() , expectedPdf.ExtractAllText());
    }

}

Friend Class PDFGeneratorTests
	<Test>
	Public Sub GenerateFinancialReport_CreatesCorrectPDF()
		' Arrange
		Dim mock = New PDFGenerator()
		Dim expectedPdf = PdfDocument.FromFile("ExpectedFinancialReport.pdf") ' Load a mock PDF

		' Act
		mock.GenerateFinancialReport("Sample report data")
		Dim actualPdf = PdfDocument.FromFile("FinancialReport.pdf")

		' Assert
		Assert.AreEqual(actualPdf.ExtractAllText(), expectedPdf.ExtractAllText())
	End Sub

End Class

In diesem Testcode wird eine PDF-Attrappe erzeugt (erwartetesPdf) die die erwartete Ausgabe darstellt, und vergleichen Sie sie mit dem PDF (actualPDF) die mit dem "PDFGenerator" erzeugt werden. Wir haben den Inhalt beider PDFs extrahiert, um zu überprüfen, ob sie den gleichen Inhalt haben.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass die Nutzung der MOQ zusammen mit IronPDF in unserem Unit-Testing-Prozess ermöglicht es uns, das Verhalten unserer Softwareanwendungen umfassend zu überprüfen. Mit MOQ können wir bestimmte Code-Komponenten isolieren, Abhängigkeiten kontrollieren und komplexe Szenarien simulieren, so dass wir gezielte und zuverlässige Tests schreiben können.

Inzwischen, IronPDF erweitert unsere Testmöglichkeiten, indem es die Generierung und Manipulation von PDF-Dokumenten erleichtert und sicherstellt, dass unsere PDF-bezogenen Funktionalitäten gründlich geprüft werden. Durch die Integration dieser Tools in unser Test-Toolkit können wir zuverlässig robuste und hochwertige Software entwickeln, die sowohl den Anforderungen an die Funktionalität als auch an die Leistung gerecht wird. Diese Kombination aus robusten Unit-Tests mit MOQ und PDF-Validierung mit IronPDF trägt wesentlich zur Gesamtqualität und Zuverlässigkeit unserer Anwendungen bei.

Es ist erwähnenswert, dass IronPDF eine kostenloser Test um seine Funktionen zu testen. Wenn Sie feststellen, dass es Ihren Bedürfnissen entspricht, haben Sie die Möglichkeit, eine handelslizenz. So können Sie die Funktionen von IronPDF weiterhin in Ihren Projekten nutzen und dabei alle Vorteile und den Support einer lizenzierten Version in Anspruch nehmen, die eine reibungslose Integration von PDF-Funktionen in Ihre Anwendungen gewährleisten.