Testen von REST-APIs in Go: Ein Leitfaden für Unit- und Integrationstests mit der Standardtestbibliothek von Go

Einführung

In diesem Artikel erfahren Sie, wie Sie Unit-Tests und Integrationstests verwenden, um Ihre Entwicklungserfahrung beim Erstellen von Rest-APIs in Golang zu verbessern.

• Unit-Tests dienen dazu, die Funktionalität kleinster, einzelner Teile einer Anwendung zu überprüfen, wobei der Schwerpunkt häufig auf einer einzelnen Funktion oder Methode liegt. Diese Tests werden isoliert von anderen Teilen des Codes durchgeführt, um sicherzustellen, dass jede Komponente für sich wie erwartet funktioniert.

• Integrationstests hingegen bewerten, wie verschiedene Module oder Komponenten der Anwendung zusammenarbeiten. In diesem Artikel konzentrieren wir uns auf Integrationstests für unsere Go-Anwendung und überprüfen insbesondere, ob sie korrekt mit einer PostgreSQL-Datenbank interagiert, indem wir erfolgreich SQL-Abfragen erstellen und ausführen.

In diesem Artikel wird davon ausgegangen, dass Sie mit Golang und der Erstellung von Rest-APIs in Golang vertraut sind. Der Schwerpunkt liegt auf der Erstellung von Tests für Ihre Routen (Unit-Tests) und dem Testen Ihrer SQL-Abfragefunktionen (Integrationstests). Besuchen Sie als Referenz den GitHub um einen Blick auf das Projekt zu werfen.

Einrichten

Angenommen, Sie haben Ihr Projekt ähnlich wie das oben verlinkte eingerichtet, dann haben Sie eine ähnliche Ordnerstruktur wie diese

test_project
|__cmd
   |__api
      |__api.go
   |__main.go
|__db
   |___seed.go
|__internal
   |___db
       |___db.go
   |___services
       |___records
           |___routes_test.go
           |___routes.go
           |___store_test.go
           |___store.go
       |___user
           |___routes_test.go
           |___routes.go
           |___store_test.go
           |___store.go
|__test_data
|__docker-compose.yml
|__Dockerfile
|__Makefile

Das Testen in Golang ist im Vergleich zu anderen Sprachen, die Sie möglicherweise kennengelernt haben, einfach, da das integrierte Testpaket die zum Schreiben von Tests erforderlichen Tools bereitstellt.
Testdateien werden mit _test.go benannt. Dieses Suffix ermöglicht es go, diese Dateien als Ziel für die Ausführung anzugeben, wenn der Befehl go test ausgeführt wird.

Der Einstiegspunkt für unser Projekt ist die Datei main.go im cmd-Ordner

// main.go

package main

import (
    "log"

    "finance-crud-app/cmd/api"
    "finance-crud-app/internal/db"

    "github.com/gorilla/mux"
    "github.com/jmoiron/sqlx"
    _ "github.com/lib/pq"
)

type Server struct {
    db  *sqlx.DB
    mux *mux.Router
}

func NewServer(db *sqlx.DB, mux *mux.Router) *Server {
    return &Server{
        db:  db,
        mux: mux,
    }
}

func main() {

    connStr := "postgres://postgres:Password123@localhost:5432/crud_db?sslmode=disable"

    dbconn, err := db.NewPGStorage(connStr)
    if err != nil {
        log.Fatal(err)
    }
    defer dbconn.Close()

    server := api.NewAPIServer(":8085", dbconn)
    if err := server.Run(); err != nil {
        log.Fatal(err)
    }
}

Aus dem Code können Sie ersehen, dass wir einen neuen API-Server erstellen, indem wir eine Datenbankverbindung und eine Portnummer übergeben. Nachdem wir den Server erstellt haben, führen wir ihn auf dem angegebenen Port aus.

Der NewAPIServer-Befehl stammt aus der api.go-Datei, die

// api.go
package api

import (
    "finance-crud-app/internal/services/records"
    "finance-crud-app/internal/services/user"
    "log"
    "net/http"

    "github.com/gorilla/mux"
    "github.com/jmoiron/sqlx"
)

type APIServer struct {
    addr string
    db   *sqlx.DB
}

func NewAPIServer(addr string, db *sqlx.DB) *APIServer {
    return &APIServer{
        addr: addr,
        db:   db,
    }
}

func (s *APIServer) Run() error {
    router := mux.NewRouter()
    subrouter := router.PathPrefix("/api/v1").Subrouter()

    userStore := user.NewStore(s.db)
    userHandler := user.NewHandler(userStore)
    userHandler.RegisterRoutes(subrouter)

    recordsStore := records.NewStore(s.db)
    recordsHandler := records.NewHandler(recordsStore, userStore)
    recordsHandler.RegisterRoutes(subrouter)

    log.Println("Listening on", s.addr)

    return http.ListenAndServe(s.addr, router)
}

Für diese API verwenden wir Mux als unseren http-Router.

Integrationstest

Wir haben eine Benutzer-Store-Struktur, die SQL-Abfragen im Zusammenhang mit der Benutzerentität verarbeitet.

// store.go
package user

import (
    "errors"
    "finance-crud-app/internal/types"
    "fmt"
    "log"

    "github.com/jmoiron/sqlx"
)

var (
    CreateUserError   = errors.New("cannot create user")
    RetrieveUserError = errors.New("cannot retrieve user")
    DeleteUserError   = errors.New("cannot delete user")
)

type Store struct {
    db *sqlx.DB
}

func NewStore(db *sqlx.DB) *Store {
    return &Store{db: db}
}

func (s *Store) CreateUser(user types.User) (user_id int, err error) {
    query := `
    INSERT INTO users
    (firstName, lastName, email, password)
    VALUES (, , , )
    RETURNING id`

    var userId int
    err = s.db.QueryRow(query, user.FirstName, user.LastName, user.Email, user.Password).Scan(&userId)
    if err != nil {
        return -1, CreateUserError
    }

    return userId, nil
}

func (s *Store) GetUserByEmail(email string) (types.User, error) {
    var user types.User

    err := s.db.Get(&user, "SELECT * FROM users WHERE email = ", email)
    if err != nil {
        return types.User{}, RetrieveUserError
    }

    if user.ID == 0 {
        log.Fatalf("user not found")
        return types.User{}, RetrieveUserError
    }

    return user, nil
}

func (s *Store) GetUserByID(id int) (*types.User, error) {
    var user types.User
    err := s.db.Get(&user, "SELECT * FROM users WHERE id = ", id)
    if err != nil {
        return nil, RetrieveUserError
    }

    if user.ID == 0 {
        return nil, fmt.Errorf("user not found")
    }

    return &user, nil
}

func (s *Store) DeleteUser(email string) error {

    user, err := s.GetUserByEmail(email)
    if err != nil {
        return DeleteUserError
    }
    // delete user records first
    _, err = s.db.Exec("DELETE FROM records WHERE userid = ", user.ID)
    if err != nil {
        return DeleteUserError
    }

    _, err = s.db.Exec("DELETE FROM users WHERE email = ", email)
    if err != nil {
        return DeleteUserError
    }
    return nil
}

In der Datei oben haben wir 3 Zeigerempfängermethoden:

• Benutzer erstellen
• GetUserByEmail
• GetUserById

Damit diese Methoden ihre Funktion erfüllen können, müssen sie mit einem externen System interagieren, in diesem Fall Postgres DB.

Um diese Methoden zu testen, erstellen wir zunächst eine Datei „store_test.go“. In Go benennen wir unsere Testdateien normalerweise nach der Datei, die wir testen möchten, und fügen das Suffix _test.go .
hinzu

// store_test.go

package user_test

import (
    "finance-crud-app/internal/db"
    "finance-crud-app/internal/services/user"
    "finance-crud-app/internal/types"
    "log"
    "os"
    "testing"

    "github.com/jmoiron/sqlx"
    _ "github.com/lib/pq"
)

var (
    userTestStore *user.Store
    testDB        *sqlx.DB
)

func TestMain(m *testing.M) {
    // database
    ConnStr := "postgres://postgres:Password123@localhost:5432/crud_db?sslmode=disable"
    testDB, err := db.NewPGStorage(ConnStr)
    if err != nil {
        log.Fatalf("could not connect %v", err)
    }
    defer testDB.Close()
    userTestStore = user.NewStore(testDB)

    code := m.Run()
    os.Exit(code)
}

func TestCreateUser(t *testing.T) {
    test_data := map[string]struct {
        user   types.User
        result any
    }{
        "should PASS valid user email used": {
            user: types.User{
                FirstName: "testfirsjjlkjt-1",
                LastName:  "testlastkjh-1",
                Email:     "validuser@email.com",
                Password:  "00000000",
            },
            result: nil,
        },
        "should FAIL invalid user email used": {
            user: types.User{
                FirstName: "testFirstName1",
                LastName:  "testLastName1",
                Email:     "test1@email.com",
                Password:  "800890",
            },
            result: user.CreateUserError,
        },
    }

    for name, tc := range test_data {
        t.Run(name, func(t *testing.T) {
            value, got := userTestStore.CreateUser(tc.user)
            if got != tc.result {
                t.Errorf("test fail expected %v got %v instead and value %v", tc.result, got, value)
            }
        })
    }

    t.Cleanup(func() {
        err := userTestStore.DeleteUser("validuser@email.com")
        if err != nil {
            t.Errorf("could not delete user %v got error %v", "validuser@email.com", err)
        }
    })
}

func TestGetUserByEmail(t *testing.T) {
    test_data := map[string]struct {
        email  string
        result any
    }{
        "should pass valid user email address used": {
            email:  "test1@email.com",
            result: nil,
        },
        "should fail invalid user email address used": {
            email:  "validuser@email.com",
            result: user.RetrieveUserError,
        },
    }

    for name, tc := range test_data {
        got, err := userTestStore.GetUserByEmail(tc.email)
        if err != tc.result {
            t.Errorf("test fail expected %v instead got %v", name, got)
        }
    }
}

func TestGetUserById(t *testing.T) {
    testUserId, err := userTestStore.CreateUser(types.User{
        FirstName: "userbyid",
        LastName:  "userbylast",
        Email:     "unique_email",
        Password:  "unique_password",
    })
    if err != nil {
        log.Panicf("got %v when creating testuser", testUserId)
    }

    test_data := map[string]struct {
        user_id int
        result  any
    }{
        "should pass valid user id used": {
            user_id: testUserId,
            result:  nil,
        },
        "should fail invalid user id used": {
            user_id: 0,
            result:  user.RetrieveUserError,
        },
    }

    for name, tc := range test_data {
        t.Run(name, func(t *testing.T) {
            _, got := userTestStore.GetUserByID(tc.user_id)
            if got != tc.result {
                t.Errorf("error retrieving user by id got %v want %v", got, tc.result)
            }
        })
    }

    t.Cleanup(func() {
        err := userTestStore.DeleteUser("unique_email")
        if err != nil {
            t.Errorf("could not delete user %v got error %v", "unique_email", err)
        }
    })
}

func TestDeleteUser(t *testing.T) {
    testUserId, err := userTestStore.CreateUser(types.User{
        FirstName: "userbyid",
        LastName:  "userbylast",
        Email:     "delete_user@email.com",
        Password:  "unique_password",
    })
    if err != nil {
        log.Panicf("got %v when creating testuser", testUserId)
    }

    test_data := map[string]struct {
        user_email string
        result     error
    }{
        "should pass user email address used": {
            user_email: "delete_user@email.com",
            result:     nil,
        },
    }

    for name, tc := range test_data {
        t.Run(name, func(t *testing.T) {
            err = userTestStore.DeleteUser(tc.user_email)
            if err != tc.result {
                t.Errorf("error deletig user got %v instead of %v", err, tc.result)
            }
        })
    }

    t.Cleanup(func() {
        err := userTestStore.DeleteUser("delete_user@email.com")
        if err != nil {
            log.Printf("could not delete user %v got error %v", "delete_user@email.com", err)
        }
    })
}

Lass uns die Datei durchgehen und sehen, was die einzelnen Abschnitte bewirken.

Die erste Aktion besteht darin, die Variablen userTestStore und testDB zu deklarieren. Diese Variablen werden zum Speichern von Zeigern auf den Benutzerspeicher bzw. die Datenbank verwendet. Der Grund, warum wir sie im globalen Dateibereich deklariert haben, liegt darin, dass wir möchten, dass alle Funktionen in der Testdatei Zugriff auf die Zeiger haben.

Mit der Funktion TestMain können wir einige Einrichtungsaktionen durchführen, bevor der Haupttest ausgeführt wird. Wir stellen zunächst eine Verbindung zum Postgres-Store her und speichern den Zeiger in unserer globalen Variablen.
Wir haben diesen Zeiger verwendet, um einen userTestStore zu erstellen, den wir zum Ausführen der SQL-Abfragen verwenden, die wir verbinden möchten.

defer testDB.Close() schließt die Datenbankverbindung, nachdem der Test abgeschlossen ist

Code := m.Run() führt den Rest der Testfunktion aus, bevor sie zurückkehrt und beendet wird.

Die Funktion

TestCreateUser übernimmt das Testen der Funktion create_user. Unser Ziel besteht darin, zu testen, ob die Funktion den Benutzer erstellt, wenn eine eindeutige E-Mail-Adresse übergeben wird, und ob die Funktion nicht in der Lage sein sollte, einen Benutzer zu erstellen, wenn eine nicht eindeutige E-Mail-Adresse bereits zum Erstellen eines anderen Benutzers verwendet wurde.

Zuerst erstellen wir die Testdaten, mit denen wir beide Fallszenarien testen werden.

test_project
|__cmd
   |__api
      |__api.go
   |__main.go
|__db
   |___seed.go
|__internal
   |___db
       |___db.go
   |___services
       |___records
           |___routes_test.go
           |___routes.go
           |___store_test.go
           |___store.go
       |___user
           |___routes_test.go
           |___routes.go
           |___store_test.go
           |___store.go
|__test_data
|__docker-compose.yml
|__Dockerfile
|__Makefile

Ich werde die Karte durchlaufen, indem ich die Funktion „create_user“ mit dem Testdatum als Parameter ausführe und vergleiche, ob der zurückgegebene Wert mit dem Ergebnis übereinstimmt, das wir erwarten

// main.go

package main

import (
    "log"

    "finance-crud-app/cmd/api"
    "finance-crud-app/internal/db"

    "github.com/gorilla/mux"
    "github.com/jmoiron/sqlx"
    _ "github.com/lib/pq"
)

type Server struct {
    db  *sqlx.DB
    mux *mux.Router
}

func NewServer(db *sqlx.DB, mux *mux.Router) *Server {
    return &Server{
        db:  db,
        mux: mux,
    }
}

func main() {

    connStr := "postgres://postgres:Password123@localhost:5432/crud_db?sslmode=disable"

    dbconn, err := db.NewPGStorage(connStr)
    if err != nil {
        log.Fatal(err)
    }
    defer dbconn.Close()

    server := api.NewAPIServer(":8085", dbconn)
    if err := server.Run(); err != nil {
        log.Fatal(err)
    }
}

In Fällen, in denen das zurückgegebene Ergebnis nicht mit dem erwarteten Ergebnis übereinstimmt, schlägt unser Test fehl

Der letzte Teil dieser Funktion verwendet die integrierte Testpaketfunktion Cleanup. Diese Funktion hat eine Funktion registriert, die aufgerufen wird, wenn alle Funktionen im Test bereits ausgeführt wurden. In unserem Beispielfall hier verwenden wir die Funktion zum Löschen von Benutzerdaten, die während der Ausführung dieser Testfunktion verwendet wurden.

Unit-Tests

Für unsere Unit-Tests werden wir die Routenhandler für unsere API testen. In diesem Fall beziehen sich die Routen auf die Benutzerentität. Beachten Sie unten.

// api.go
package api

import (
    "finance-crud-app/internal/services/records"
    "finance-crud-app/internal/services/user"
    "log"
    "net/http"

    "github.com/gorilla/mux"
    "github.com/jmoiron/sqlx"
)

type APIServer struct {
    addr string
    db   *sqlx.DB
}

func NewAPIServer(addr string, db *sqlx.DB) *APIServer {
    return &APIServer{
        addr: addr,
        db:   db,
    }
}

func (s *APIServer) Run() error {
    router := mux.NewRouter()
    subrouter := router.PathPrefix("/api/v1").Subrouter()

    userStore := user.NewStore(s.db)
    userHandler := user.NewHandler(userStore)
    userHandler.RegisterRoutes(subrouter)

    recordsStore := records.NewStore(s.db)
    recordsHandler := records.NewHandler(recordsStore, userStore)
    recordsHandler.RegisterRoutes(subrouter)

    log.Println("Listening on", s.addr)

    return http.ListenAndServe(s.addr, router)
}

Wir haben hier drei Funktionen, die wir testen möchten

• HandleLogin
• HandleRegister
• HandleGetUser

HandleGetUser

Die handleGetUser-Funktion in diesem Handler ruft Benutzerdetails basierend auf einer Benutzer-ID ab, die in der HTTP-Anforderungs-URL bereitgestellt wird. Es beginnt mit dem Extrahieren der Benutzer-ID aus den Anforderungspfadvariablen mithilfe des Mux-Routers. Wenn die Benutzer-ID fehlt oder ungültig (keine Ganzzahl) ist, wird mit dem Fehler 400 Bad Request geantwortet. Nach der Validierung ruft die Funktion die GetUserByID-Methode im Datenspeicher auf, um Benutzerinformationen abzurufen. Wenn beim Abruf ein Fehler auftritt, wird ein 500 Internal Server Error zurückgegeben. Bei Erfolg antwortet es mit dem Status „200 OK“ und sendet die Benutzerdetails als JSON im Antworttext.

Wie bereits erwähnt, müssen wir zum Testen der Handlerfunktionen ein routes_test.go erstellen. Siehe meine unten

test_project
|__cmd
   |__api
      |__api.go
   |__main.go
|__db
   |___seed.go
|__internal
   |___db
       |___db.go
   |___services
       |___records
           |___routes_test.go
           |___routes.go
           |___store_test.go
           |___store.go
       |___user
           |___routes_test.go
           |___routes.go
           |___store_test.go
           |___store.go
|__test_data
|__docker-compose.yml
|__Dockerfile
|__Makefile

Unsere Funktion „Neuer Handler“ erfordert einen Benutzerspeicher als Parameter, damit sie eine Handlerstruktur erstellen kann.
Da wir keinen tatsächlichen Speicher benötigen, erstellen wir eine Scheinstruktur und Empfängerfunktionen, die die Funktion der tatsächlichen Struktur nachahmen. Wir tun dies, weil wir die Store-Funktionstests separat durchführen und daher diesen Teil des Codes nicht in den Handler-Tests testen müssen.

Die Testfunktion TestGetUserHandler testet zwei Fallszenarien: Das erste ist der Versuch, einen Benutzer abzurufen, ohne die Benutzer-ID anzugeben

// main.go

package main

import (
    "log"

    "finance-crud-app/cmd/api"
    "finance-crud-app/internal/db"

    "github.com/gorilla/mux"
    "github.com/jmoiron/sqlx"
    _ "github.com/lib/pq"
)

type Server struct {
    db  *sqlx.DB
    mux *mux.Router
}

func NewServer(db *sqlx.DB, mux *mux.Router) *Server {
    return &Server{
        db:  db,
        mux: mux,
    }
}

func main() {

    connStr := "postgres://postgres:Password123@localhost:5432/crud_db?sslmode=disable"

    dbconn, err := db.NewPGStorage(connStr)
    if err != nil {
        log.Fatal(err)
    }
    defer dbconn.Close()

    server := api.NewAPIServer(":8085", dbconn)
    if err := server.Run(); err != nil {
        log.Fatal(err)
    }
}

Der Test wird voraussichtlich bestanden, wenn die HTTP-Anfrage mit einem 400-Statuscode antwortet.

Das zweite Testfallszenario sind Fälle, in denen wir Benutzerinformationen mithilfe der richtigen URL abrufen, die eine gültige Benutzer-ID enthält. In diesem Testfall haben wir eine Antwort mit dem Statuscode 200 erwartet. Andernfalls ist der Test fehlgeschlagen.

// api.go
package api

import (
    "finance-crud-app/internal/services/records"
    "finance-crud-app/internal/services/user"
    "log"
    "net/http"

    "github.com/gorilla/mux"
    "github.com/jmoiron/sqlx"
)

type APIServer struct {
    addr string
    db   *sqlx.DB
}

func NewAPIServer(addr string, db *sqlx.DB) *APIServer {
    return &APIServer{
        addr: addr,
        db:   db,
    }
}

func (s *APIServer) Run() error {
    router := mux.NewRouter()
    subrouter := router.PathPrefix("/api/v1").Subrouter()

    userStore := user.NewStore(s.db)
    userHandler := user.NewHandler(userStore)
    userHandler.RegisterRoutes(subrouter)

    recordsStore := records.NewStore(s.db)
    recordsHandler := records.NewHandler(recordsStore, userStore)
    recordsHandler.RegisterRoutes(subrouter)

    log.Println("Listening on", s.addr)

    return http.ListenAndServe(s.addr, router)
}

Abschluss

Wir haben es geschafft, Unit-Tests in unserem Projekt zu implementieren, indem wir Tests für unsere Routenhandler erstellt haben. Wir haben gesehen, wie man Mocks verwendet, um nur eine kleine Codeeinheit zu testen. Wir konnten Integrationstests für unsere Funktion entwickeln, die mit der Postgresql-Datenbank interagieren.
Wenn Sie etwas praktische Zeit mit dem Projektcode haben möchten, klonen Sie das Repo von Github hier

Das obige ist der detaillierte Inhalt vonTesten von REST-APIs in Go: Ein Leitfaden für Unit- und Integrationstests mit der Standardtestbibliothek von Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!