C# Unit-Testing (Funktionsweise für Entwickler)

Erstellen eines Unit-Test-Projekts

Um mit dem Unit-Testing in C# zu beginnen, müssen Sie eines der Unit-Test-Projekte in Visual Studio einrichten. Visual Studio bietet ein integriertes Unit-Testing-Framework, das einen einfachen Start ermöglicht. Wenn Sie ein neues Projekt erstellen, wählen Sie die Vorlage 'Unit Test Project' unter der C#-Kategorie. Diese Vorlage richtet alles ein, was Sie zum Erstellen und Ausführen von Unit-Tests benötigen.

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;

namespace Unit_Test_Project_Example
{
    // A simple calculator class with an Add method
    public class Calculator
    {
        public int Add(int a, int b)
        {
            return a + b;
        }
    }

    // A test class to validate the functionality of the Calculator class
    [TestClass]
    public class CalculatorTests
    {
        // A test method to check if the Add method in Calculator returns the correct sum
        [TestMethod]
        public void Add_ShouldReturnCorrectSum()
        {
            // Arrange
            var calculator = new Calculator();

            // Act
            var result = calculator.Add(2, 2);

            // Assert
            Assert.AreEqual(4, result);
        }
    }
}

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;

namespace Unit_Test_Project_Example
{
    // A simple calculator class with an Add method
    public class Calculator
    {
        public int Add(int a, int b)
        {
            return a + b;
        }
    }

    // A test class to validate the functionality of the Calculator class
    [TestClass]
    public class CalculatorTests
    {
        // A test method to check if the Add method in Calculator returns the correct sum
        [TestMethod]
        public void Add_ShouldReturnCorrectSum()
        {
            // Arrange
            var calculator = new Calculator();

            // Act
            var result = calculator.Add(2, 2);

            // Assert
            Assert.AreEqual(4, result);
        }
    }
}

Verstehen von Testmethoden und Testklassen

In einem Unit-Test-Projekt organisieren Sie Tests in Klassen und Methoden. Eine Testklasse repräsentiert eine Sammlung von Unit-Test-Methoden, die zusammen ausgeführt werden sollen. Jede Unit-Test-Methode, die mit dem Attribut [TestMethod] versehen ist, enthält die Logik zum Testen einer bestimmten Funktion Ihres Codes. Die Testklasse selbst ist mit dem Attribut [TestClass] gekennzeichnet, was dem Testframework signalisiert, dass sie Tests zur Ausführung enthält.

Verwendung des Test Explorers in Visual Studio

Das Test Explorer-Fenster von Visual Studio ist Ihr zentrales Zentrum zum Ausführen und Verwalten aller Testmethoden. Sie können alle Tests, eine Auswahl von Tests oder einzelne Tests ausführen. Nach dem Ausführen von Tests bietet der Test Explorer eine detaillierte Zusammenfassung über bestandene und fehlgeschlagene Tests, sodass Sie Probleme schnell identifizieren und beheben können.

Interpretation von Testergebnissen

• Bestandene Tests: Diese Tests wurden erfolgreich ausgeführt, was darauf hinweist, dass sich der getestete Code unter den angegebenen Bedingungen wie erwartet verhält.
• Fehlgeschlagene Tests: Diese weisen auf eine Diskrepanz zwischen den erwarteten und den tatsächlichen Ergebnissen hin und signalisieren mögliche Fehler oder Missverständnisse in den Anforderungen oder im Testcode.

Es ist entscheidend, fehlgeschlagene Tests umgehend zu untersuchen, da sie ein frühes Warnzeichen für Probleme in Ihrem Code sein können.

Effektive Organisation von Tests

Eine gute Organisation ist der Schlüssel zur Pflege einer großen Test-Suite. Gruppieren Sie Ihre Tests logisch nach der Funktionalität, die sie abdecken. Verwenden Sie beschreibende Namen für Ihre Testmethoden und -klassen, um anzugeben, was jeder Test überprüft. Dieser Ansatz erleichtert das Auffinden und Verstehen von Tests später, insbesondere wenn Ihre Testsuite wächst.

Mocking und Dependency Injection

Oftmals interagiert der zu testende Code mit externen Ressourcen oder anderen Teilen Ihrer Anwendung. In solchen Fällen verwenden Sie Mocking-Frameworks wie Moq oder NSubstitute, um Mock-Objekte zu erstellen. Diese Stellvertreter ahmen das Verhalten der echten Objekte nach und erlauben Ihnen, Ihren Code isoliert zu testen. Dependency Injection macht Ihren Code testbarer, da es ermöglicht, reale Abhängigkeiten während des Testens durch Mocks oder Stubs zu ersetzen.

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;

// A sample test class demonstrating the use of mocks
[TestClass]
public class ProductServiceTests
{
    // A test method to verify the GetProductById method of ProductService
    [TestMethod]
    public void GetProductById_ShouldReturnCorrectProduct()
    {
        // Arrange
        var mockRepository = new Mock<IProductRepository>();
        mockRepository.Setup(x => x.FindById(1)).Returns(new Product { Id = 1, Name = "Laptop" });

        ProductService productService = new ProductService(mockRepository.Object);

        // Act
        Product result = productService.GetProductById(1);

        // Assert
        Assert.IsNotNull(result);
        Assert.AreEqual("Laptop", result.Name);
    }
}

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;

// A sample test class demonstrating the use of mocks
[TestClass]
public class ProductServiceTests
{
    // A test method to verify the GetProductById method of ProductService
    [TestMethod]
    public void GetProductById_ShouldReturnCorrectProduct()
    {
        // Arrange
        var mockRepository = new Mock<IProductRepository>();
        mockRepository.Setup(x => x.FindById(1)).Returns(new Product { Id = 1, Name = "Laptop" });

        ProductService productService = new ProductService(mockRepository.Object);

        // Act
        Product result = productService.GetProductById(1);

        // Assert
        Assert.IsNotNull(result);
        Assert.AreEqual("Laptop", result.Name);
    }
}

Datengetriebene Tests nutzen

Datengetriebene Tests ermöglichen es Ihnen, dieselbe Testmethode mehrfach mit unterschiedlichen Eingabedaten auszuführen. Diese Technik ist besonders nützlich, um eine breite Palette von Eingaben und Szenarien zu testen, ohne mehrere Testmethoden schreiben zu müssen. Visual Studio unterstützt datengetriebenes Testen, indem Sie Ihre Testdaten aus verschiedenen Quellen wie Inline-Daten, CSV-Dateien oder Datenbanken angeben können.

Asserts verstehen und effektiv nutzen

Asserts sind das Herz Ihrer Testmethoden, da sie die Ergebnisse Ihrer Tests validieren. Verstehen Sie die Bandbreite der Assert-Methoden, die in Ihrem Testframework verfügbar sind, und verwenden Sie diese entsprechend, um erwartete Werte, Ausnahmen oder Bedingungen zu überprüfen. Die richtige Assert-Nutzung kann Ihre Tests klarer und robuster machen.

Kontinuierliche Integration und Testautomatisierung

Integrieren Sie Ihre Unit-Tests in Ihre Continuous-Integration-(CI-)Pipeline. Dies stellt sicher, dass Tests automatisch jedes Mal ausgeführt werden, wenn Änderungen am Code vorgenommen werden, was hilft, Probleme frühzeitig zu erkennen und zu beheben. Automatisierung erleichtert auch das häufige und konsistente Ausführen von Tests, was entscheidend für die Pflege eines gesunden Codes ist.

Tests und Produktionscode auf dem gleichen Stand halten

Ihre Unit-Tests sind nur so gut wie ihre Übereinstimmung mit dem Produktionscode. Stellen Sie sicher, dass alle Änderungen an der Funktionalität in den entsprechenden Unit-Tests widergespiegelt werden. Diese Praxis verhindert, dass veraltete Tests fälschlicherweise bestehen und stellt sicher, dass Ihre Testsuite den Zustand Ihrer Anwendung genau wiedergibt.

Aus fehlgeschlagenen Tests lernen

Wenn ein Test fehlschlägt, ist das eine Gelegenheit zum Lernen und zur Verbesserung. Ein fehlgeschlagener Test kann unerwartete Verhaltensweisen, falsche Annahmen oder Bereiche Ihres Codes offenlegen, die komplexer und fehleranfälliger sind, als nötig. Analysieren Sie fehlgeschlagene Tests sorgfältig, um ihre zugrunde liegenden Ursachen zu verstehen und verwenden Sie diese Erkenntnisse, um sowohl Ihre Tests als auch Ihren Produktionscode zu verbessern.

Codebeispiel

Hier ist ein Beispiel, wie Sie IronPDF in einem C#-Unit-Testing-Szenario verwenden könnten. Angenommen, Sie möchten eine Funktion testen, die ein PDF aus HTML-Inhalten generiert. Sie könnten IronPDF verwenden, um das HTML als PDF zu rendern und dann das Vorhandensein oder den Inhalt des PDFs als Teil Ihres Tests zu überprüfen:

using IronPdf;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.IO;

// A sample test class to verify PDF generation
[TestClass]
public class PdfGenerationTests
{
    // A test method to verify HTML to PDF generation using IronPDF
    [TestMethod]
    public void TestHtmlToPdfGeneration()
    {
        IronPdf.License.LicenseKey = "License-Key"; // Set your IronPDF license key

        var renderer = new ChromePdfRenderer();

        // Render HTML to a PDF
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, world!</h1>");

        string filePath = Path.Combine(Path.GetTempPath(), "test.pdf");

        // Save the generated PDF to a file
        pdf.SaveAs(filePath);

        // Assert the PDF file was created successfully
        Assert.IsTrue(File.Exists(filePath), "The generated PDF does not exist.");

        // Additional assertions to verify the PDF content could be added here
        // Clean up generated file
        File.Delete(filePath);
    }
}

using IronPdf;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.IO;

// A sample test class to verify PDF generation
[TestClass]
public class PdfGenerationTests
{
    // A test method to verify HTML to PDF generation using IronPDF
    [TestMethod]
    public void TestHtmlToPdfGeneration()
    {
        IronPdf.License.LicenseKey = "License-Key"; // Set your IronPDF license key

        var renderer = new ChromePdfRenderer();

        // Render HTML to a PDF
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, world!</h1>");

        string filePath = Path.Combine(Path.GetTempPath(), "test.pdf");

        // Save the generated PDF to a file
        pdf.SaveAs(filePath);

        // Assert the PDF file was created successfully
        Assert.IsTrue(File.Exists(filePath), "The generated PDF does not exist.");

        // Additional assertions to verify the PDF content could be added here
        // Clean up generated file
        File.Delete(filePath);
    }
}

Dieses Beispiel zeigt einen einfachen Unit-Test, der IronPDF verwendet, um ein PDF aus einem HTML-String zu generieren, es in einer temporären Datei zu speichern und dann die Existenz der Datei zu überprüfen.