In der Welt der Softwareentwicklung ist das Testen ein unverzichtbarer Prozess. Es stellt sicher, dass Ihr Code wie erwartet funktioniert und hilft, Fehler zu erkennen, bevor sie in die Produktion gelangen. Ein wesentlicher Aspekt des Testens ist das Mocking, und wenn es um C#-Tests geht, ist MOQ ein leistungsstarkes Tool im Arsenal eines Entwicklers. Es unterstützt 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# befassen.

Was ist MOQ?

MOQ - Mocking Framework for .NET ist ein Mocking-Framework for .NET-Anwendungen, das Entwicklern ermöglicht, schnell und effizient Mock-Objekte zu erstellen. Mock-Objekte simulieren das Verhalten von echten Objekten in Ihrer Anwendung und erleichtern es Ihnen, bestimmte Teile Ihres Codes zu isolieren und zu testen. MOQ vereinfacht den Prozess der Erstellung und Arbeit mit diesen Mock-Objekten.

Schlüsselmerkmale von MOQ

• Fluent Interface: MOQ bietet eine fließende und ausdrucksstarke API zum Einrichten von Erwartungen und Überprüfungen. Dies macht Ihren Testcode lesbarer und leichter verständlich.
• Starke Typisierung: MOQ nutzt die Sprachmerkmale von C#, um starke Typisierung und IntelliSense-Unterstützung beim Definieren von Mocks und Erwartungen zu bieten. Dies verringert die Wahrscheinlichkeit von Laufzeitfehlern in Ihren Tests.
• Lockeres Mocking: MOQ unterstützt sowohl striktes als auch lockeres Mocking. Lockeres Mocking ermöglicht es Ihnen, Mock-Objekte zu erstellen, die auf beliebige Methodenaufrufe reagieren, während striktes Mocking erzwingt, dass nur erwartete Methoden aufgerufen werden.
• Überprüfbares Verhalten: MOQ erlaubt es Ihnen zu überprüfen, dass bestimmte Methoden auf Ihren Mock-Objekten mit den erwarteten Argumenten und in der richtigen Reihenfolge aufgerufen wurden.
• Callbacks und Rückgaben: Sie können Callbacks definieren, um benutzerdefinierten Code auszuführen, wenn eine gemockte Methode aufgerufen wird, und Rückgabewerte für gemockte Methoden angeben.

Einstieg mit MOQ

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

Erstellen Sie ein Neues C#-Projekt

Folgen Sie diesen Schritten, um ein neues Projekt zu erstellen:

1. Öffnen Sie Visual Studio, gehen Sie zu "Datei" > "Neu" > "Projekt...".
2. Wählen Sie eine Vorlage, konfigurieren Sie die Einstellungen und klicken Sie auf 'Erstellen'.

Angenommen, Sie entwickeln Software für einen Geldautomaten (Automated Teller Machine) und müssen die Authentifizierungs- und Abhebungsfunktionalität testen. Der Geldautomat hängt von zwei Schnittstellen ab: IHostBank und IHSMModule. Wir möchten die ATMCashWithdrawal-Klasse testen, die die Bargeldabhebungsfunktionalität des Geldautomaten repräsentiert.

Erstellen Sie zwei Schnittstellen, IHostBank und IHSMModule, die die Abhängigkeiten des Geldautomatensystems 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

' 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 ATMCashWithdrawal-Klasse, die die oben genannten Abhängigkeiten nutzt, um Geldautomatenvorgänge auszuführen. In dieser Klasse implementieren Sie eine bestimmte Methode wie WithdrawAmount.

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

    // Withdraw amount after validating PIN and balance
    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;
    }

    // Withdraw amount after validating PIN and balance
    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

	' Withdraw amount after validating PIN and balance
	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

' 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

	' Withdraw amount after validating PIN and balance
	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

Ein Unit-Test-Projekt erstellen

Nun lassen Sie uns Unit-Tests für die ATMCashWithdrawal-Klasse erstellen, indem wir MOQ verwenden, um die Abhängigkeiten zu mocken.

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

Um ein NUnit-Testprojekt zu Ihrer Visual Studio-Lösung hinzuzufügen, folgen Sie diesen Schritten:

1. Rechtsklick auf die Lösung: Im Solution Explorer (normalerweise auf der rechten Seite) klicken Sie mit der rechten Maustaste auf den Lösungsnamen.
2. Hinzufügen > Neues Projekt: Wählen Sie im Kontextmenü "Hinzufügen" und dann "Neues Projekt...".
3. Neues Projekt erstellen: Im Dialog "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. Projekt konfigurieren: Konfigurieren Sie die Projekteinstellungen nach Bedarf, einschließlich Projektname und Speicherort.
5. Klicken Sie auf OK: Klicken Sie auf die Schaltfläche "Erstellen" oder "OK", um das NUnit-Testprojekt zu Ihrer Lösung hinzuzufügen.

Nun 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 beginnen, Ihre NUnit-Testfälle in diesem Projekt zu schreiben.

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-Paket-Manager in Visual Studio oder durch Ausführen des folgenden Befehls in der Paket-Manager-Konsole tun:

Install-Package Moq

Install-Package Moq

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

Schreiben Sie Unit-Tests mit NUnit und MOQ, um die Abhängigkeiten (IHostBank und IHSMModule) der ATMCashWithdrawal-Klasse zu mocken.

using Moq;
using NUnit.Framework;

namespace ATMSystem.Tests
{
    public class ATMTests
    {
        private ATMCashWithdrawal atmCash;

        [SetUp]
        public void Setup()
        {
            // Arrange - Setup mock objects
            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);

            atmCash = new ATMCashWithdrawal(hsmModuleMock.Object, hostBankMock.Object);
        }

        [Test]
        public void WithdrawAmount_ValidTransaction_ReturnsTrue()
        {
            // Act - Execute the method under test
            bool result = atmCash.WithdrawAmount("123456781234", 1234, 500);

            // Assert - Verify the result
            Assert.IsTrue(result);
        }

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

using Moq;
using NUnit.Framework;

namespace ATMSystem.Tests
{
    public class ATMTests
    {
        private ATMCashWithdrawal atmCash;

        [SetUp]
        public void Setup()
        {
            // Arrange - Setup mock objects
            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);

            atmCash = new ATMCashWithdrawal(hsmModuleMock.Object, hostBankMock.Object);
        }

        [Test]
        public void WithdrawAmount_ValidTransaction_ReturnsTrue()
        {
            // Act - Execute the method under test
            bool result = atmCash.WithdrawAmount("123456781234", 1234, 500);

            // Assert - Verify the result
            Assert.IsTrue(result);
        }

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

Imports Moq
Imports NUnit.Framework

Namespace ATMSystem.Tests
	Public Class ATMTests
		Private atmCash As ATMCashWithdrawal

		<SetUp>
		Public Sub Setup()
			' Arrange - Setup mock objects
			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)

			atmCash = New ATMCashWithdrawal(hsmModuleMock.Object, hostBankMock.Object)
		End Sub

		<Test>
		Public Sub WithdrawAmount_ValidTransaction_ReturnsTrue()
			' Act - Execute the method under test
			Dim result As Boolean = atmCash.WithdrawAmount("123456781234", 1234, 500)

			' Assert - Verify the result
			Assert.IsTrue(result)
		End Sub

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

Imports Moq
Imports NUnit.Framework

Namespace ATMSystem.Tests
	Public Class ATMTests
		Private atmCash As ATMCashWithdrawal

		<SetUp>
		Public Sub Setup()
			' Arrange - Setup mock objects
			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)

			atmCash = New ATMCashWithdrawal(hsmModuleMock.Object, hostBankMock.Object)
		End Sub

		<Test>
		Public Sub WithdrawAmount_ValidTransaction_ReturnsTrue()
			' Act - Execute the method under test
			Dim result As Boolean = atmCash.WithdrawAmount("123456781234", 1234, 500)

			' Assert - Verify the result
			Assert.IsTrue(result)
		End Sub

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

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

Im obigen Codebeispiel haben wir das Konzept des Mockens von Objekten mit MOQ in C# demonstriert. Wir erstellen Mock-Objekte für die IHSMModule- und IHostBank-Schnittstellen und simulieren ihr Verhalten während des Unit-Testens. Dies ermöglicht es uns, die ATMCashWithdrawal-Klasse zu isolieren und gründlich zu testen, indem wir die Antworten dieser Mock-Objekte steuern. Durch Mocking können wir sicherstellen, dass unser Code korrekt mit diesen Abhängigkeiten interagiert, wodurch unsere Tests fokussiert, vorhersehbar und effektiv bei der Identifizierung von Problemen innerhalb der spezifischen Codeeinheit unter Untersuchung sind. Diese Praxis erhöht die allgemeine Zuverlässigkeit, Wartbarkeit und Qualität des Testcodes.

Schritt 3 Ausführen der Tests

1. Erstellen Sie Ihre Lösung, um sie zu aktualisieren.
2. Öffnen Sie den Test-Explorer in Visual Studio (Test > Test-Explorer).
3. Klicken Sie auf die Schaltfläche "Alle ausführen" im Test-Explorer, um Ihre Unit-Tests auszuführen.
4. Überprüfen Sie die Testergebnisse. Sie sollten sehen, dass der Test, den Sie geschrieben haben (WithdrawAmount_ValidTransaction_ReturnsTrue), bestanden wird.

Auf diese Weise können wir den Code, den wir testen wollen, isolieren und sicherstellen, dass er sich wie erwartet unter verschiedenen Szenarien verhält, indem wir Abhängigkeiten effektiv mocken. Diese Praxis verbessert die Zuverlässigkeit und Wartbarkeit Ihrer Software und erleichtert das frühzeitige Erkennen und Beheben von Problemen im Entwicklungsprozess.

Einführung in IronPDF

IronPDF-Dokumentation und Funktionsübersicht ist eine leistungsstarke C#-Bibliothek, die es Entwicklern ermöglicht, innerhalb ihrer Anwendungen mit PDF-Dokumenten zu arbeiten. Sie bietet eine breite Palette von Funktionen, einschließlich Erstellen, Modifizieren und Konvertieren von PDF-Dateien aus verschiedenen Quellen wie HTML, Bildern und bestehenden PDFs. Kombiniert mit dem Konzept des Mockens von Objekten, wie im vorherigen Tutorial besprochen, kann IronPDF ein wertvolles Tool zur Erstellung und Bearbeitung von PDF-Dokumenten in Ihren Unit-Tests sein.

Das Hauptmerkmal von IronPDF ist die HTML-zu-PDF-Konvertierungsfunktion, die sicherstellt, dass Layouts und Stile intakt bleiben. Es wandelt Webinhalte in PDFs um und ist somit ideal für Berichte, Rechnungen und Dokumentationen.

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

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, das die Erstellung oder Verarbeitung von PDFs beinhaltet, können Sie IronPDF verwenden, um Mock-PDF-Dokumente zu erstellen, die reale Szenarien nachahmen. Dies kann besonders nützlich für das Testen und Validieren sein, wie Ihr Code mit PDF-Dateien interagiert. Sie können Mock-PDFs mit spezifischem Inhalt, Layouts und Eigenschaften erzeugen und diese als Testvorlagen verwenden, um sicherzustellen, dass Ihr Code die gewünschten PDF-Ausgaben produziert oder korrekt mit PDF-bezogenen Operationen umgeht.

Mock-Objekte für die Generierung von PDFs erstellen

Angenommen, Sie entwickeln eine Anwendung, die Finanzberichte generiert, und diese Berichte müssen als PDF-Dokumente gespeichert und verteilt werden. In diesem Szenario möchten Sie möglicherweise die PDF-Erstellung testen und sicherstellen, dass der Inhalt und das Format korrekt sind.

Zuerst müssen wir IronPDF zu unserem Projekt hinzufügen. Schreiben Sie den folgenden Befehl in der NuGet-Paket-Manager-Konsole, um IronPDF zu installieren.

Install-Package IronPdf

Dieser Befehl installiert IronPDF und fügt die notwendigen Abhängigkeiten zu unserem Projekt hinzu.

So kann IronPDF in den Unit-Test-Prozess integriert werden:

Erzeugung von Mock-PDFs

Sie können IronPDF verwenden, um Mock-PDF-Dokumente mit spezifischem Inhalt und Styling zu erstellen, um echte Finanzberichte nachzuahmen. Diese Mock-PDFs können als Testvorlagen für Ihre Unit-Tests dienen, wie im folgenden Codeausschnitt 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.SaveAs("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.SaveAs("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(reportData As String)
        Dim renderer As 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.SaveAs("FinancialReport.pdf")
    End Sub

    Private Function GenerateReportHtml(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

Public Class PDFGenerator
    Public Sub GenerateFinancialReport(reportData As String)
        Dim renderer As 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.SaveAs("FinancialReport.pdf")
    End Sub

    Private Function GenerateReportHtml(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 schreiben, um IronPDF zur Erzeugung von Mock-PDFs zu verwenden, die verschiedene Szenarien von Berichten darstellen. Dann vergleichen wir die tatsächlichen PDFs, die von unserem Code generiert werden, mit diesen Mock-PDFs, um sicherzustellen, dass der Inhalt, das Format und die Struktur wie erwartet sind.

using IronPdf;
using NUnit.Framework;

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

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

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

using IronPdf;
using NUnit.Framework;

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

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

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

Imports IronPdf
Imports NUnit.Framework

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

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

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

Imports IronPdf
Imports NUnit.Framework

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

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

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

In diesem Testcode erzeugen wir ein Mock-PDF (expectedPdf), das die erwartete Ausgabe darstellt, und vergleichen es mit dem PDF (actualPdf), das von der PDFGenerator-Klasse erzeugt wird. Wir haben den Inhalt beider PDFs extrahiert, um zu überprüfen, ob sie denselben Inhalt haben.

Abschluss

Zusammenfassend lässt sich sagen, dass die Nutzung von MOQ zusammen mit IronPDF in unserem Unit-Testprozess es uns ermöglicht, das Verhalten unserer Softwareanwendungen umfassend zu überprüfen. MOQ befähigt uns, spezifische Codekomponenten zu isolieren, Abhängigkeiten zu kontrollieren und komplexe Szenarien zu simulieren, wodurch wir fokussierte und zuverlässige Tests schreiben können.

In der Zwischenzeit erweitert IronPDF unsere Testfähigkeiten, indem es die Erstellung und Bearbeitung von PDF-Dokumenten erleichtert und sicherstellt, dass unsere PDF-bezogenen Funktionalitäten gründlich untersucht werden. Durch die Integration dieser Tools in unser Testtoolkit können wir sicher robuste und qualitativ hochwertige Software entwickeln, die den Anforderungen sowohl an Funktionalität als auch an Leistung gerecht wird. Diese Kombination aus robustem Unit-Testing mit MOQ und PDF-Validierung mit IronPDF trägt erheblich zur Gesamtqualität und Zuverlässigkeit unserer Anwendungen bei.

Es ist erwähnenswert, dass IronPDF eine kostenlose Testversion zum Testen seiner Funktionen anbietet. Wenn Sie feststellen, dass es Ihren Bedürfnissen entspricht, haben Sie die Möglichkeit, eine kommerzielle Lizenz zu erwerben, die es Ihnen ermöglicht, die Funktionen von IronPDF weiterhin in Ihren Projekten zu nutzen, mit dem vollen Vorteil und Support, die mit einer lizenzierten Version einhergehen, um die reibungslose Integration von PDF-bezogenen Funktionen in Ihre Anwendungen sicherzustellen.