Golang-Integrationstest mit Gin, Gorm, Testify, PostgreSQL

Das Erstellen eines umfassenden Integrationstest-Setups in Golang mit Gin, GORM, Testify und PostgreSQL umfasst das Einrichten einer Testdatenbank, das Schreiben von Tests für CRUD-Operationen und die Verwendung von Testify für Behauptungen. Hier ist eine Schritt-für-Schritt-Anleitung für den Einstieg:

Voraussetzungen

• Installiert gehen
• Docker installiert
• Bibliotheken: gin-gonic/gin, gorm.io/gorm, gorm.io/driver/postgres, testify, testcontainers-go

Projektstruktur

myapp/
|-- main.go
|-- models/
|   |-- models.go
|-- handlers/
|   |-- handlers.go
|-- tests/
|   |-- integration_test.go
|-- go.mod
|-- go.sum

1. Richten Sie die Modelle ein (models/models.go)

Definieren Sie die Modelle mit GORM-Tags für die Datenbankzuordnung.

package models

import (
    "time"
    "gorm.io/gorm"
)

type User struct {
    ID        uint           `gorm:"primaryKey"`
    Name      string         `gorm:"not null"`
    Email     string         `gorm:"unique;not null"`
    CreatedAt time.Time
}

type Book struct {
    ID            uint           `gorm:"primaryKey"`
    Title         string         `gorm:"not null"`
    Author        string         `gorm:"not null"`
    PublishedDate time.Time      `gorm:"not null"`
}

type BorrowLog struct {
    ID         uint           `gorm:"primaryKey"`
    UserID     uint           `gorm:"not null"`
    BookID     uint           `gorm:"not null"`
    BorrowedAt time.Time      `gorm:"default:CURRENT_TIMESTAMP"`
    ReturnedAt *time.Time
}

2. Handler einrichten (handlers/handlers.go)

Definieren Sie die Routen und Handler für CRUD-Operationen mit Gin.

package handlers

import (
    "myapp/models"
    "net/http"

    "github.com/gin-gonic/gin"
    "gorm.io/gorm"
)

type Handler struct {
    DB *gorm.DB
}

func (h *Handler) CreateUser(c *gin.Context) {
    var user models.User
    if err := c.ShouldBindJSON(&user); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    if err := h.DB.Create(&user).Error; err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    c.JSON(http.StatusCreated, user)
}

func (h *Handler) GetUser(c *gin.Context) {
    var user models.User
    if err := h.DB.First(&user, c.Param("id")).Error; err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error": "User not found"})
        return
    }

    c.JSON(http.StatusOK, user)
}

func (h *Handler) UpdateUser(c *gin.Context) {
    var user models.User
    if err := h.DB.First(&user, c.Param("id")).Error; err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error": "User not found"})
        return
    }

    if err := c.ShouldBindJSON(&user); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    if err := h.DB.Save(&user).Error; err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    c.JSON(http.StatusOK, user)
}

func (h *Handler) DeleteUser(c *gin.Context) {
    if err := h.DB.Delete(&models.User{}, c.Param("id")).Error; err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    c.JSON(http.StatusOK, gin.H{"message": "User deleted"})
}

3. Hauptanwendung (main.go)

Richten Sie die Datenbankverbindung und Routen ein.

package main

import (
    "myapp/handlers"
    "myapp/models"
    "github.com/gin-gonic/gin"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
    "log"
    "os"
)

func main() {
    dsn := "host=localhost user=postgres password=yourpassword dbname=testdb port=5432 sslmode=disable"
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        log.Fatalf("failed to connect to database: %v", err)
    }

    // Auto migrate the models
    db.AutoMigrate(&models.User{}, &models.Book{}, &models.BorrowLog{})

    h := handlers.Handler{DB: db}

    r := gin.Default()

    r.POST("/users", h.CreateUser)
    r.GET("/users/:id", h.GetUser)
    r.PUT("/users/:id", h.UpdateUser)
    r.DELETE("/users/:id", h.DeleteUser)

    r.Run(":8080")
}

4. Integrationstest (tests/integration_test.go)

Verwenden Sie Testify zum Einrichten und Bestätigen von Testergebnissen.

Für die Datenbank können wir zu Testzwecken eine Dockerized PostgreSQL-Instanz verwenden, die isoliert ist und nach Tests schnell abgebaut werden kann. So richten Sie es in Golang mit testcontainers-go ein:

Testcontainers-go installieren:

go get github.com/testcontainers/testcontainers-go

Es folgt die Datei „integration_test.go“, die einen PostgreSQL-Container zum Testen einrichtet:

myapp/
|-- main.go
|-- models/
|   |-- models.go
|-- handlers/
|   |-- handlers.go
|-- tests/
|   |-- integration_test.go
|-- go.mod
|-- go.sum

Erläuterung

• SetupTestDB: Richtet eine PostgreSQL-Datenbankverbindung mit GORM zum Testen ein.
• TestCreateUser: Sendet eine POST-Anfrage zum Erstellen eines neuen Benutzers und bestätigt die Antwort.
• TestGetUser: Ruft einen Benutzer anhand seiner ID ab und prüft, ob die Daten mit den eingegebenen Daten übereinstimmen.
• TestUpdateUser:
  • Erstellt einen Benutzer und aktualisiert ihn mithilfe des PUT /users/:id-Endpunkts.
  • Bestätigt, dass der Antwortstatus 200 OK ist.
  • Überprüft, ob die Benutzerdetails in der Antwort aktualisiert werden.
  • Ruft den Benutzer aus der Datenbank ab und bestätigt, dass die Änderungen beibehalten werden.
• TestDeleteUser:
  • Erstellt einen Benutzer und löscht ihn mit dem Endpunkt DELETE /users/:id.
  • Bestätigt, dass der Antwortstatus 200 OK ist, und prüft, ob eine Erfolgsmeldung vorliegt.
  • Versuche, den gelöschten Benutzer aus der Datenbank abzurufen, um sicherzustellen, dass der Benutzer nicht mehr existiert, und behaupten dabei den Fehler gorm.ErrRecordNotFound.
• testcontainers-go: Mit dieser Bibliothek können Sie Docker-Container direkt aus Ihrem Go-Code starten. Es eignet sich ideal zum Erstellen einer temporären PostgreSQL-Instanz für Integrationstests.
• setupTestDB: Diese Funktion startet einen PostgreSQL-Docker-Container, stellt über Gorm eine Verbindung zu ihm her und richtet das Datenbankschema ein. Es stellt außerdem sicher, dass der Behälter nach Abschluss der Tests aufgeräumt wird.
• defer postgresC.Terminate(ctx): Stellt sicher, dass der PostgreSQL-Container nach Abschluss der Tests beendet wird, wodurch ein In-Memory-Ansatz simuliert wird.
• Dynamischer Host und Port: Verwendet den dynamisch zugewiesenen Host und Port des Containers für die Verbindung mit der Datenbank.

Ausführen der Tests

Führen Sie die Tests aus mit:

myapp/
|-- main.go
|-- models/
|   |-- models.go
|-- handlers/
|   |-- handlers.go
|-- tests/
|   |-- integration_test.go
|-- go.mod
|-- go.sum

Vorteile der Verwendung von testcontainers-go:

1. Isolierung: Jeder Testlauf erhält eine neue PostgreSQL-Instanz, um sicherzustellen, dass zwischen den Tests kein Datenverlust auftritt.
2. Repliziert die Produktionsumgebung: Tests mit einer echten PostgreSQL-Instanz liefern zuverlässigere Ergebnisse als die Verwendung einer In-Memory-Datenbank.
3. Automatisierung: Startet und stoppt den PostgreSQL-Container automatisch und erleichtert so die Verwendung in CI/CD-Pipelines.

Wichtige Punkte

• Verwendung einer Testdatenbank: Es empfiehlt sich, zum Testen eine separate PostgreSQL-Datenbank (z. B. in Containern) zu verwenden, um eine Beeinträchtigung der Produktionsdaten zu vermeiden.
• Einrichtung und Bereinigung: Stellen Sie sicher, dass Sie die Datenbank zwischen den Tests bereinigen, um die Konsistenz zu gewährleisten.
• Testify: Bietet leistungsstarke Behauptungsmethoden zur Validierung der Ergebnisse.
• Gin's Test Server: Verwendet httptest zur Simulation von HTTP-Anfragen an den Gin-Server.

Mit diesem Setup können Sie CRUD-Vorgänge für ein Benutzermodell testen und so sicherstellen, dass die API mit PostgreSQL wie erwartet funktioniert. Sie können die Tests auf ähnliche Weise für die Modelle „Book“ und „BorrowLog“ erweitern.

Das obige ist der detaillierte Inhalt vonGolang-Integrationstest mit Gin, Gorm, Testify, PostgreSQL. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!