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

Ein neues C#-Projekt erstellen

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 ist von zwei Schnittstellen abhängig: IHostBank und IHSMModule. Wir möchten die Klasse ATMCashWithdrawal testen, die die Bargeldabhebungsfunktion 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

Erstellen Sie die Klasse ATMCashWithdrawal, die die oben genannten Abhängigkeiten verwendet, um ATM-Operationen durchzuführen. In diesem Kurs 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

Ein Unit-Test-Projekt erstellen

Jetzt erstellen wir Unit-Tests für die Klasse ATMCashWithdrawal, wobei wir MOQ verwenden, um die Abhängigkeiten zu simulieren.

Erstellen Sie ein neues Unit-Test-Projekt in Ihrer Projektmappe und benennen 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

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 Klasse ATMCashWithdrawal zu simulieren.

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

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

Im obigen Codebeispiel haben wir das Konzept des Mockens von Objekten mit MOQ in C# demonstriert. Wir erstellen Mock-Objekte für die Schnittstellen IHSMModule und IHostBank, um deren Verhalten während der Unit-Tests zu simulieren. Dies ermöglicht es uns, die Klasse ATMCashWithdrawal zu isolieren und gründlich zu testen, indem wir die Reaktionen dieser Mock-Objekte kontrollieren. 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 von Ihnen geschriebene Test (WithdrawAmount_ValidTransaction_ReturnsTrue) erfolgreich war.

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.

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(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.SaveAs("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 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

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