Ujian Integrasi Golang Dengan Gin, Gorm, Testify, PostgreSQL

Mencipta persediaan ujian integrasi yang komprehensif di Golang dengan Gin, GORM, Testify dan PostgreSQL melibatkan penyediaan pangkalan data ujian, menulis ujian untuk operasi CRUD dan menggunakan Testify untuk penegasan. Berikut ialah panduan langkah demi langkah untuk membolehkan anda bermula:

Prasyarat

• Pergi dipasang
• Docker dipasang
• Perpustakaan: gin-gonic/gin, gorm.io/gorm, gorm.io/driver/postgres, testimoni, testcontainers-go

Struktur Projek

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

1. Sediakan Model (models/models.go)

Tentukan model dengan teg GORM untuk pemetaan pangkalan data.

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. Pengendali Persediaan (pengendali/pengendali.go)

Tentukan laluan dan pengendali untuk operasi CRUD menggunakan 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. Aplikasi Utama (main.go)

Sediakan sambungan pangkalan data dan laluan.

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. Ujian Integrasi (tests/integration_test.go)

Gunakan Testify untuk menyediakan dan menegaskan keputusan ujian.

Untuk pangkalan data, kami boleh menggunakan contoh PostgreSQL Dockerized untuk tujuan ujian, yang diasingkan dan boleh dirobohkan dengan cepat selepas ujian. Begini cara untuk menyediakannya di Golang menggunakan testcontainers-go:

Pasang testcontainers-go:

go get github.com/testcontainers/testcontainers-go

Berikut ialah fail integration_test.go yang menyediakan bekas PostgreSQL untuk ujian:

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

Penjelasan

• SetupTestDB: Sediakan sambungan pangkalan data PostgreSQL menggunakan GORM untuk ujian.
• TestCreateUser: Menghantar permintaan POST untuk mencipta pengguna baharu dan menegaskan respons.
• TestGetUser: Mendapatkan semula pengguna melalui ID dan menyemak sama ada data sepadan dengan apa yang dimasukkan.
• TestUpdateUser:
  • Mencipta pengguna dan mengemas kininya menggunakan titik akhir PUT /users/:id.
  • Menegaskan bahawa status respons ialah 200 OK.
  • Sahkan bahawa butiran pengguna dikemas kini dalam respons.
  • Mengambil pengguna daripada pangkalan data dan mengesahkan bahawa perubahan itu berterusan.
• TestDeleteUser:
  • Mencipta pengguna dan memadamkannya menggunakan titik akhir DELETE /users/:id.
  • Menegaskan bahawa status respons ialah 200 OK dan menyemak mesej kejayaan.
  • Percubaan untuk mengambil pengguna yang dipadamkan daripada pangkalan data untuk memastikan pengguna tidak lagi wujud, menegaskan ralat gorm.ErrRecordNotFound.
• testcontainers-go: Pustaka ini membolehkan anda memutarkan bekas Docker terus daripada kod Go anda. Ia sesuai untuk mencipta contoh PostgreSQL sementara untuk ujian penyepaduan.
• setupTestDB: Fungsi ini memulakan bekas PostgreSQL Docker, menyambung kepadanya menggunakan gorm, dan menyediakan skema pangkalan data. Ia juga memastikan bekas dibersihkan selepas ujian selesai.
• defer postgresC.Terminate(ctx): Memastikan bekas PostgreSQL ditamatkan selepas ujian dilakukan, mensimulasikan pendekatan dalam ingatan.
• Hos dan Port Dinamik: Menggunakan hos dan port yang diperuntukkan secara dinamik bagi kontena untuk menyambung ke pangkalan data.

Menjalankan Ujian

Jalankan ujian menggunakan:

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

Faedah Menggunakan testcontainers-go:

1. Pengasingan: Setiap ujian yang dijalankan mendapat contoh PostgreSQL baharu, memastikan tiada kebocoran data antara ujian.
2. Meniru Persekitaran Pengeluaran: Ujian terhadap contoh PostgreSQL sebenar memberikan hasil yang lebih dipercayai daripada menggunakan pangkalan data dalam memori.
3. Automasi: Memulakan dan menghentikan bekas PostgreSQL secara automatik, menjadikannya mudah untuk digunakan dalam saluran paip CI/CD.

Perkara Utama

• Menggunakan Pangkalan Data Ujian: Amalan yang baik untuk menggunakan pangkalan data PostgreSQL yang berasingan (cth: yang disimpan dalam bekas) untuk ujian bagi mengelakkan menjejaskan data pengeluaran.
• Persediaan dan Pembersihan: Pastikan untuk membersihkan pangkalan data antara ujian untuk mengekalkan konsistensi.
• Bersaksi: Menyediakan kaedah penegasan yang kuat untuk mengesahkan keputusan.
• Gin's Test Server: Menggunakan httptest untuk mensimulasikan permintaan HTTP terhadap pelayan Gin.

Dengan persediaan ini, anda boleh menguji operasi CRUD untuk model Pengguna, memastikan API berfungsi seperti yang diharapkan dengan PostgreSQL. Anda boleh mengembangkan ujian yang sama untuk model Book dan BorrowLog.

Atas ialah kandungan terperinci Ujian Integrasi Golang Dengan Gin, Gorm, Testify, PostgreSQL. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!