Testen von C# .NET-Anwendungen: Einheit, Integration und End-to-End-Test

C# .NET-Anwendungstest-Teststrategien umfassen Unit-Tests, Integrationstests und End-to-End-Tests. 1. Unit -Test stellt sicher, dass die Mindesteinheit des Codes unter Verwendung des Frameworks MStest, Nunit oder Xunit unabhängig funktioniert. 2. Integriertes Test überprüft die Funktionen mehrerer Einheiten kombinierter, häufig verwendeter simulierter Daten und externer Dienste. 3. Die End-to-End-Tests simuliert den vollständigen Betriebsprozess des Benutzers und verwenden normalerweise Selen für automatisierte Tests.

Einführung

In der Welt der Softwareentwicklung ist das Testen wie ein Sicherheitsnetz für den Code, den wir schreiben. Insbesondere bei der Entwicklung mit C# und .NET ist das Testen nicht nur ein kritischer Schritt, um die Qualität Ihres Codes, sondern auch eine Kunst zu gewährleisten. Heute werden wir uns mit Teststrategien für C# .NET-Anwendungen befassen, einschließlich Unit-Tests, Integrationstests und End-to-End-Tests. In diesem Artikel lernen Sie, wie Sie Ihre C# -Anwendung effektiv testen und die Vorteile und Herausforderungen verschiedener Testtypen verstehen.

Überprüfung des Grundwissens

Das Testen ist überall in der Softwareentwicklung, aber wir müssen mehrere wichtige Testtypen klären. Die Unit -Tests konzentrieren sich auf die kleinste Codeeinheit, normalerweise eine Methode oder Funktion. Integrationstests überprüfen, ob mehrere Einheiten korrekt zusammenarbeiten. End-to-End-Tests simuliert den vollständigen Betriebsprozess des Benutzers, um sicherzustellen, dass das gesamte System wie erwartet funktioniert.

In C# .NET umfassen unsere häufig verwendeten Test -Frameworks MStest, Nunit und Xunit. Diese Frameworks bieten eine Fülle von Tools und APIs, um uns zu helfen, Tests zu schreiben und auszuführen.

Kernkonzept oder Funktionsanalyse

Definition und Funktion von Unit -Tests

Unit -Tests ist die minimale Granularität des Tests, die sicherstellt, dass jede Codeeinheit unabhängig funktioniert. Durch Unit -Tests können wir schnell Probleme finden und beheben und die Wartbarkeit und Zuverlässigkeit unseres Codes verbessern. Der Kern der Unit -Tests ist die Unabhängigkeit und das schnelle Rückmeldung.

Ein einfaches Beispiel für Einheiten -Tests:

 mit Xunit;

öffentliche Klassenberechnung
{
    [Tatsache]
    public void add_twopositivenumbers_returnScorrectSum ()
    {
        // Arrangieren
        var rechner = neuer recherator ();

        // Akt
        var result = calculate.add (2, 3);

        // Assert
        Assert.Equal (5, Ergebnis);
    }
}

Dieser Code zeigt einen Unit -Test eines einfachen Additionsvorgangs. Auf diese Weise können wir sicherstellen, dass die Add -Methode in Calculator unter verschiedenen Eingaben korrekt funktioniert.

Wie Integrationstests funktioniert

Der Zweck der Integrationstests besteht darin, die Funktionalität mehrerer Einheiten zusammen zu überprüfen. Es funktioniert durch die Simulation des Datenflusss und der Interaktion in einer realen Umgebung, um sicherzustellen, dass Komponenten nahtlos funktionieren können. Integrationstests erfordert häufig mehr Setup- und Scheindaten, kann jedoch Integrationsprobleme erkennen, die Unit -Tests nicht erfassen können.

Ein Beispiel für Integrationstest:

 mit Xunit;

öffentliche Klasse UserServicetests
{
    [Tatsache]
    öffentliche asynchronisierte Aufgabe getuser_validuserid_returnsuser ()
    {
        // Arrangieren
        var userService = new UserService (new FakeUserRepository ());
        var userID = "123";

        // Akt
        var user = warte userService.getUser (userId);

        // Assert
        Assert.notnull (Benutzer);
        Assert.Equal ("John Doe", Benutzer.name);
    }
}

In diesem Beispiel haben wir die UserService -Klasse getestet, die sich auf ein User -Repository stützt. Wir verwenden ein gefälschtes Repository, um reale Datenquellen zu simulieren, wodurch die Logik der Serviceschicht überprüft wird.

Das Implementierungsprinzip von End-to-End-Tests

Durch End-to-End-Tests simuliert der vollständige Betriebsprozess von Benutzern, die normalerweise UI-Interaktions- und Datenbankvorgänge umfassen. Das Implementierungsprinzip besteht darin, das Benutzerverhalten durch Automatisierungstools (wie Selenium) zu simulieren und zu überprüfen, ob die Funktionen des Systems von Anfang bis Ende normal sind.

Ein End-to-End-Testbeispiel:

 mit Xunit;
mit OpenQA.Selenium;
mit OpenQa.selenium.chrome;

öffentliche Klasse Logints
{
    [Tatsache]
    public void login_validcredentials_redirectStodashboard ()
    {
        // Arrangieren
        Iwebdriver driver = new Chromedriver ();
        triver.navigate (). GotOurl ("https://example.com/login");

        // Akt
        triver.Findelement (von.id ("Benutzername")). sendkeys ("user");
        Driver.Findelement (by.id ("Passwort")). Sendkeys ("Passwort");
        Driver.Findelement (by.id ("loginButton")). click ();

        // Assert
        Assert.Contains ("Dashboard", Treiber.Title);
        Driver.quit ();
    }
}

In diesem Beispiel wird angezeigt, wie Selenium für End-to-End-Tests verwendet werden, die Benutzeranmeldeberationen simulieren und überprüfen, ob es erfolgreich zum Dashboard springt.

Beispiel für die Nutzung

Grundlegende Verwendung von Unit -Tests

Die grundlegende Verwendung von Unit -Tests besteht darin, unabhängige Testmethoden zu schreiben, wodurch jeweils eine bestimmte Funktion oder ein bestimmtes Verhalten getestet wird. Hier ist ein einfaches Beispiel:

 mit Xunit;

öffentliche Klasse Stringcalculatests
{
    [Tatsache]
    public void add_emptystring_returnszero ()
    {
        var calculate = new StringCalculator ();
        var result = calculate.add ("");
        Assert.Equal (0, Ergebnis);
    }

    [Tatsache]
    public void add_singlenumber_returnsnumber ()
    {
        var calculate = new StringCalculator ();
        var result = calculate ("5");
        Assert.Equal (5, Ergebnis);
    }
}

Diese Testmethoden testen das Verhalten der Add -Methode StringCalculator -Klasse unter leeren Zeichenfolgen bzw. einzelne numerische Eingänge.

Erweiterte Verwendung von Integrationstests

Die fortgeschrittene Nutzung von Integrationstests umfasst die Verspottung externer Dienste und Datenbankoperationen. Hier ist ein Beispiel für die Verwendung der MOQ -Bibliothek, um externe Dienste zu simulieren:

 mit Xunit;
mit MOQ;

öffentliche Klasse OrderServicetests
{
    [Tatsache]
    public async task placeorder_validorder_callspaymentService ()
    {
        // Arrangieren
        var MockPaymentService = New Mock <PaymentService> ();
        var orderService = new orderService (MockPaymentService.Object);
        var order = new order {pension = 100};

        // Akt
        Warten Sie orderService.PlaceOrder (Reihenfolge);

        // Assert
        MockPaymentService.Verify (ps => ps.ProcessPayment (order.Amount), Times.once);
    }
}

In diesem Beispiel verwenden wir die MOQ -Bibliothek, um den Zahlungsdienst zu simulieren und zu überprüfen, ob OrderService den Zahlungsdienst bei der Aufgabe einer Bestellung korrekt aufruft.

Häufige Fehler und Debugging-Tipps für End-to-End-Tests

Häufige Fehler bei End-to-End-Tests umfassen Elementpositionierungsfehler, unzureichende Wartezeit usw. Hier finden Sie einige Debugging-Tipps:

• Verwenden Sie explizite Warten, um sicherzustellen, dass das Element lädt:

 var wait = neuer Webdriverwait (Treiber, Timesspan.Fromseconds (10));
var element = wait.until (d => d.Findelement (by.id ("myelement"));

• Verwenden Sie die Protokollierung, um den Testausführungsprozess zu verfolgen, um Probleme zu finden:

 unter Verwendung von microsoft.extensions.logging;

öffentliche Klasse Logints
{
    private readonly iloogger <loginests> _logger;

    öffentliche Loginten (Iloogger <Logints> Logger)
    {
        _logger = logger;
    }

    [Tatsache]
    public void login_validcredentials_redirectStodashboard ()
    {
        _logger.loginformation ("Anmeldetest starten");
        // ... Testcode ...
        _logger.loginformation ("Anmeldetest abgeschlossen");
    }
}

Leistungsoptimierung und Best Practices

Leistungsoptimierung und Best Practices sind beim Testen von C# .NET -Anwendungen von entscheidender Bedeutung. Hier sind einige Vorschläge:

• Testabdeckung : Stellen Sie sicher, dass Ihre Tests kritische Codepfade abdecken. Verwenden Sie ein Tool wie die Deckung, um die Testabdeckung zu messen:

 DOTNET -Test /P: CollectCoverage = True /P: CoverletOutputFormat = lcov /p:coverletoutput=./Coverage/lcov.info

• Testparallelisierung : Verwenden Sie die Parallelisierungsfunktion des Testframeworks, um die Testausführung zu beschleunigen. In Xunit kann beispielsweise die parallele Ausführung von Tests durch das [collection] -attribut gesteuert werden:

 [Sammlung ("MyCollection")]
öffentliche Klasse Mytests
{
    // Testmethode}

• Code -Lesbarkeit : Schreiben Sie klare und prägnante Testcode mit aussagekräftigen Namen und Kommentaren:

 [Tatsache]
public void calculatetotalprice_withdiscount_applydiscountCorrecty ()
{
    // Arrangieren
    var order = new order {price = 100, rabatt = 10};

    // Akt
    var TotalPrice = order.calculatetotalprice ();

    // Assert
    Assert.Equal (90, TotalPrice); // 100 - 10% = 90
}

Durch diese Strategien und Praktiken können wir nicht nur die Effizienz und Qualität des Tests verbessern, sondern auch sicherstellen, dass unsere C# .NET -Anwendungen in verschiedenen Szenarien stabil arbeiten können. Ich hoffe, dieser Artikel bietet Ihnen wertvolle Erkenntnisse und praktische Tipps, die Ihnen helfen, weiter auf dem Weg zum Test zu gehen.

Das obige ist der detaillierte Inhalt vonTesten von C# .NET-Anwendungen: Einheit, Integration und End-to-End-Test. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!