Entdecken Sie einige beliebte Testbibliotheken in Golang

Golang ist eine relativ junge Programmiersprache, erfreut sich aber bei Entwicklern bereits großer Beliebtheit. Weil es sich besonders für den Aufbau leistungsstarker Webdienste eignet, aber auch über Zuverlässigkeit und Einfachheit verfügt. Für einen erfahrenen Entwickler ist das Schreiben von Code nicht schwierig, aber die Frage, wie die Programmqualität beim Schreiben von Code sichergestellt werden kann, insbesondere wie der Code getestet wird, ist eine zentrale Frage.

In diesem Artikel wird erläutert, wie Tests in Golang durchgeführt werden. Wir werden Unit-Tests und Integrationstests vorstellen. Gleichzeitig werden wir auch einige beliebte Testbibliotheken erkunden, darunter Test und Goconvey.

Was ist Unit-Test?

Einheitentests beziehen sich auf Entwickler, die die kleinsten testbaren Softwareeinheiten testen, um sicherzustellen, dass sie ordnungsgemäß funktionieren. In Golang bezieht sich dies normalerweise auf Funktionen und Methoden.

Unit-Tests sind automatisiert, was bedeutet, dass Sie Code schreiben müssen, um Ihren Code zu testen. Der Code wird dann ausgeführt und ein detaillierter Fehlerbericht wird bereitgestellt, wenn der Test fehlschlägt. Da die Tests automatisiert sind, können Sie sie ohne manuelle Eingriffe durchführen.

Schauen wir uns ein Beispiel an. Nehmen wir an, wir haben eine Datei namens „adder.go“, die eine Funktion namens „Add()“ enthält, die zwei Zahlen addiert. Das Folgende ist der Inhalt von „adder_test.go“, der zum Testen der Funktion „Add()“ in „adder.go“ verwendet wird:

package main

import (
    "testing"
)

func TestAdd(t *testing.T) {
    expected := 4
    actual := Add(2, 2)

    if actual != expected {
        t.Errorf("Add(): expected %d but got %d", expected, actual)
    }
}

Der Schwerpunkt des Unit-Tests liegt darauf, das Verhalten der Funktion zu testen und ob sie funktioniert entspricht dem erwarteten Verhalten. Wir testen nicht nur, ob die Funktion „Add()“ die Summe zweier Zahlen korrekt berechnet, sondern auch, ob sie dem erwarteten Wert entspricht. Wenn der Test fehlschlägt, wird uns eine Fehlermeldung mit dem gesuchten Ergebnis angezeigt, damit wir den Fehler leicht finden und beheben können.

Was ist Integrationstest?

Integrationstests beziehen sich auf die Art von Softwaretests, mit denen mehrere Komponenten getestet werden, um die Interaktion zwischen ihnen zu überprüfen. Bei Webanwendungen umfasst dies in der Regel einen End-to-End-Test des Servers, um sicherzustellen, dass der Webdienst vollständig integriert und für die Ausführung in einer realen Umgebung bereit ist.

In Golang umfasst der Integrationstest normalerweise das Testen von HTTP-Handlern oder RPC-Methoden. Nachfolgend finden Sie den Code für einen Beispiel-Integrationstest, der testet, ob die HTTP-Handler-Funktion HTTP-Anfragen korrekt verarbeiten kann:

package main

import (
    "io/ioutil"
    "net/http"
    "net/http/httptest"
    "testing"
)

func TestHelloHandler(t *testing.T) {
    req, err := http.NewRequest("GET", "/", nil)
    if err != nil {
        t.Fatal(err)
    }

    rr := httptest.NewRecorder()
    handler := http.HandlerFunc(HelloHandler)

    handler.ServeHTTP(rr, req)

    if status := rr.Code; status != http.StatusOK {
        t.Errorf("handler returned wrong status code: got %v want %v",
            status, http.StatusOK)
    }

    expected := "Hello, World!"
    if rr.Body.String() != expected {
        t.Errorf("handler returned unexpected body: got %v want %v",
            rr.Body.String(), expected)
    }
}

Für Integrationstests verwenden wir normalerweise das httptest-Paket, um solche Anfragen zu verarbeiten. Damit können wir eine Dummy-HTTP-Anfrage erstellen und diese über den Webdienst weiterleiten, den wir testen möchten.

Testbibliothek in Golang

testing

testing ist das offizielle Testframework der Go-Sprache. Das Framework ist in die Standardbibliothek der Go-Sprache integriert und erfordert daher keine zusätzlichen Importe. Es bietet einige einfache Funktionen und Typen zum Schreiben von Unit- und Integrationstests.

Das Folgende ist ein Beispielcode aus der Testbibliothek, der eine Funktion namens „Square()“ testet:

package main

import (
    "testing"
)

func TestSquare(t *testing.T) {
    cases := []struct {
        name         string
        input, want  int
    }{
        {
            "positive",
            3,
            9,
        },
        {
            "zero",
            0,
            0,
        },
        {
            "negative",
            -2,
            4,
        },
    }

    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            got := Square(tc.input)
            if got != tc.want {
                t.Errorf("For (%d), got (%d), expected (%d)",
                    tc.input, got, tc.want)
            }
        })
    }
}

Jetzt stellt uns die Testbibliothek eine praktische Funktion zur Verfügung, die es uns ermöglicht, denselben Test mit mehreren Testfällen auszuführen Gleichung. Dies ist die Funktion t.Run(), die einen untergeordneten Test erstellt und ihn unserem übergeordneten Test zuordnet. Welche Version von Square() schnitt in allen Testfällen am besten ab? Wir können dies herausfinden, indem wir mit t.Run() für jeden Testfall separate Tests ausführen.

goconvey

goconvey ist ein beliebtes Testframework von Drittanbietern, mit dem Sie testen können, wie Funktionen und Methoden funktionieren, und schnell erkennen können, welche Tests bestanden werden und welche nicht.

Im Gegensatz zu Testbibliotheken können Sie mit goconvey den Kontext Ihres Testcodes erstellen, indem Sie Text kopieren, anstatt eine Funktion zu erstellen. Das bedeutet, dass Sie nicht jedes Mal den gleichen Testfallcode schreiben müssen. goconvey generiert automatisch Tests und stellt eine Zusammenfassung der Ergebnisse bereit, was die Verwendung erleichtert.

Hier ist ein Beispielcode aus dem Goconvey-Framework, der eine Funktion namens „Greet()“ testet:

package main

import (
    . "github.com/smartystreets/goconvey/convey"
    "testing"
)

func TestGreet(t *testing.T) {
    Convey("Given a name and a greeting message", t, func() {
        name := "John"
        greeting := "Hello"

        Convey("When we pass the name and greeting to Greet()", func() {
            message, err := Greet(name, greeting)

            Convey("Then there is no error", func() {
                So(err, ShouldBeNil)

                Convey("And the message contains the name and greeting", func() {
                    So(message, ShouldEqual, "Hello, John")
                })
            })
        })
    })
}

Bitte beachten Sie, dass wir „Convey“ anstelle von „Run“ oder „Test“ verwendet haben, um das gewünschte Szenario zu beschreiben prüfen . Dies liegt daran, dass goconvey einen verhaltensgesteuerten Entwicklungsstil verwendet. In unserem Beispiel ist „Convey()“ eine Funktion, die ein Unit-Test-Szenario beschreibt. Jedes Szenario beschreibt eine andere Situation, die eintreten könnte, und definiert die zu überprüfenden Ergebnisse. Ähnlich wie bei der Testbibliothek können wir Funktionen wie So/ShouldBeNil verwenden, um die Ergebnisse zu ändern und sicherzustellen, dass unsere Erwartungen erfüllt werden.

Fazit

Unit-Tests und Integrationstests sind ein integraler Bestandteil des Golang-Entwicklungsprozesses. Sie tragen dazu bei, dass unser Code wie erwartet funktioniert. Testing und Goconvey sind zwei leistungsstarke Bibliotheken, die einige schnelle und benutzerfreundliche Funktionen und Typen zum Testen von Funktionen und Methoden bereitstellen. Wenn Sie diese Bibliotheken noch nicht verwendet haben und mehr über das Testen in Go erfahren möchten, probieren Sie sie aus.

Das obige ist der detaillierte Inhalt vonEntdecken Sie einige beliebte Testbibliotheken in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!