Während wir diese API entwickelt haben, haben wir uns mit Authentifizierung, Protokollierung, Dockerisierung und mehr befasst. Aber eine Sache, über die wir noch nicht gesprochen haben, ist das Testen! Wenn Sie möchten, dass Ihre API produktionsbereit ist, ist das Hinzufügen solider Unit-Tests von entscheidender Bedeutung. In diesem Beitrag gehen wir auf die Grundlagen des Unit-Tests in Go ein, damit Sie Fehler frühzeitig erkennen und qualitativ hochwertigen Code liefern können.

Warum Unit-Tests?

Unit-Tests helfen Ihnen zu überprüfen, ob jeder Teil Ihrer Codebasis wie erwartet funktioniert. Sie sind Ihre erste Verteidigungslinie gegen Bugs, Regressionen und andere böse Überraschungen. Mit der integrierten Testbibliothek von Go können Sie schnell Tests einrichten, die:

• Stellen Sie ein konsistentes Verhalten Ihrer Funktionen sicher.
• Erleichtern Sie das Refactoring von Code, ohne neue Probleme einzuführen.
• Steigern Sie Ihr Vertrauen, dass alles so funktioniert, wie es sollte.

Bereit, loszulegen? Lass uns eintauchen! ?

Schritt 1: Einrichten eines Basistests

Gos Test-Framework ist einfach und direkt in die Sprache integriert. Sie können eine Testdatei erstellen, indem Sie sie mit dem Suffix _test.go benennen. Beginnen wir mit dem Testen einer einfachen Funktion in main.go:

// main.go
package main

func Add(a, b int) int {
    return a   b
}

Erstellen Sie nun eine Datei mit dem Namen main_test.go und fügen Sie den folgenden Code hinzu:

// main_test.go
package main

import "testing"

func TestAdd(t *testing.T) {
    result := Add(2, 3)
    expected := 5

    if result != expected {
        t.Errorf("Add(2, 3) = %d; want %d", result, expected)
    }
}

So funktioniert es:

1. Testfunktion: Jede Testfunktion in Go muss mit Test beginnen und einen *testing.T-Parameter akzeptieren.
2. Behauptung: Wir prüfen, ob das Ergebnis unserer Erwartung entspricht. Ist dies nicht der Fall, protokollieren wir einen Fehler mit t.Errorf.

Um den Test auszuführen, verwenden Sie einfach:

go test

Wenn alles funktioniert, wird eine OK-Meldung angezeigt. ?

Schritt 2: Testen von HTTP-Handlern

Jetzt schreiben wir einen Test für einen unserer HTTP-Handler. Wir verwenden das httptest-Paket von Go, um einen simulierten HTTP-Anfrage- und Antwortrekorder zu erstellen.

// main_test.go
package main

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

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

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

    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)
    }
}

Erläuterung:

1. httptest.NewRequest: Erstellt eine neue HTTP-Anfrage. Dies täuscht eine Anfrage an Ihren /books-Endpunkt vor.
2. httptest.NewRecorder: Verspottet eine HTTP-Antwort. Wir werden dies später überprüfen, um zu sehen, ob es unseren Erwartungen entspricht.
3. ServeHTTP: Ruft unseren getBooks-Handler mit der Scheinanfrage und dem Rekorder auf.

Auf diese Weise können Sie Ihre Handler isolieren und testen, ohne einen vollständigen Server hochfahren zu müssen. ?

Schritt 3: Ausführen von Tests mit Abdeckung

Go verfügt über eine integrierte Möglichkeit, die Testabdeckung zu überprüfen. Um zu sehen, wie viel Prozent Ihres Codes von Tests abgedeckt werden, können Sie Folgendes ausführen:

go test -cover

Für eine detailliertere Berichterstattung erstellen Sie einen HTML-Bericht:

go test -coverprofile=coverage.out
go tool cover -html=coverage.out

Öffnen Sie die generierte HTML-Datei, um zu visualisieren, welche Teile Ihres Codes abgedeckt sind. Dies ist eine fantastische Möglichkeit, herauszufinden, wo möglicherweise zusätzliche Tests erforderlich sind.

Schritt 4: Externe Abhängigkeiten verspotten

Wenn Sie Funktionen testen, die von externen Diensten abhängen (z. B. Datenbank- oder externe API-Aufrufe), können Sie Schnittstellen verwenden, um diese Abhängigkeiten zu simulieren.

// Define a simple interface for our database
type Database interface {
    GetBooks() ([]Book, error)
}

// Implement a mock database
type MockDatabase struct{}

func (m MockDatabase) GetBooks() ([]Book, error) {
    return []Book{{Title: "Mock Book"}}, nil
}

Durch die Verwendung von Schnittstellen können Sie beim Testen die tatsächliche Abhängigkeit durch Ihren Schein ersetzen. Dadurch bleiben Ihre Tests schnell, isoliert und wiederholbar.

Was kommt als nächstes?

Nachdem Sie mit der Erstellung von Unit-Tests begonnen haben, versuchen Sie, Tests zu anderen Teilen Ihrer API hinzuzufügen! ? Nächste Woche werden wir uns mit der Integration einer CI/CD-Pipeline befassen, damit diese Tests bei jeder Änderung automatisch ausgeführt werden können. Bleiben Sie dran!

Frage an Sie: Was ist Ihr Lieblings-Testwerkzeug oder Ihre Lieblingstechnik? Schreiben Sie unten einen Kommentar – ich würde gerne hören, wie andere Go-Entwickler an das Testen herangehen!

Mit diesen Grundlagen sind Sie auf dem besten Weg, solide Tests zu schreiben, die Ihre Go-API zuverlässiger machen. Weitere Testtipps und fortgeschrittene Techniken finden Sie in zukünftigen Beiträgen. Viel Spaß beim Testen! ?