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.
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.
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:
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 FunktionTestCreateUser ü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.
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
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)
}
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!
Der Unterschied zwischen Mac Air und Pro
Was ist der Grund dafür, dass keine Verbindung zum Server hergestellt werden konnte?
Der Ordner wird zur Exe
Wayos Soft-Routing
Der Unterschied zwischen Scilab und Matlab
js-Methode zum Löschen des Knotens
Daten vom Android-Telefon auf das Apple-Telefon migrieren
Lösung für das Zurücksetzen der Verbindung
