Golang测试中使用临时数据库进行验证

:memory:

go-sqlite3

:memory:

import (
    "database/sql"
    _ "github.com/mattn/go-sqlite3" // Import the SQLite driver
    "testing"
)

func setupInMemoryDB(t *testing.T) *sql.DB {
    db, err := sql.Open("sqlite3", ":memory:") // Use :memory: for an in-memory database
    if err != nil {
        t.Fatalf("failed to open in-memory database: %v", err)
    }

    // Example: Create a table
    _, err = db.Exec(`CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT);`)
    if err != nil {
        t.Fatalf("failed to create table: %v", err)
    }

    t.Cleanup(func() { // Ensure the database connection is closed after the test
        db.Close()
    })
    return db
}

func TestUserCreation(t *testing.T) {
    db := setupInMemoryDB(t)
    // Now you can use 'db' for your test logic
    _, err := db.Exec("INSERT INTO users (name) VALUES (?)", "Alice")
    if err != nil {
        t.Errorf("failed to insert user: %v", err)
    }

    var name string
    err = db.QueryRow("SELECT name FROM users WHERE id = ?", 1).Scan(&name)
    if err != nil {
        t.Errorf("failed to query user: %v", err)
    }
    if name != "Alice" {
        t.Errorf("expected name Alice, got %s", name)
    }
}

testcontainers-go

// This is a conceptual example for testcontainers-go
// You'd need to import "github.com/testcontainers/testcontainers-go" and a specific database module
// For example, "github.com/testcontainers/testcontainers-go/modules/postgres"

/*
func setupPostgresContainer(t *testing.T) (*sql.DB, func()) {
    ctx := context.Background()

    // Request a PostgreSQL container
    pgContainer, err := postgres.RunContainer(ctx,
        testcontainers.WithImage("postgres:13"),
        postgres.WithDatabase("testdb"),
        postgres.WithUsername("testuser"),
        postgres.WithPassword("testpass"),
    )
    if err != nil {
        t.Fatalf("failed to start postgres container: %v", err)
    }

    // Get connection string
    connStr, err := pgContainer.ConnectionString(ctx, "sslmode=disable")
    if err != nil {
        t.Fatalf("failed to get connection string: %v", err)
    }

    db, err := sql.Open("pgx", connStr) // Assuming you use pgx driver
    if err != nil {
        t.Fatalf("failed to open database connection: %v", err)
    }

    // Ping to ensure connection is ready
    if err = db.PingContext(ctx); err != nil {
        t.Fatalf("failed to ping database: %v", err)
    }

    // Return the DB connection and a cleanup function
    return db, func() {
        db.Close()
        pgContainer.Terminate(ctx)
    }
}

func TestPostgresIntegration(t *testing.T) {
    db, cleanup := setupPostgresContainer(t)
    defer cleanup()

    // Your test logic using the 'db' connection
    // ...
}
*/

TestMain

testing.T.Cleanup()

// Example using T.Cleanup() within a test function
func TestSomethingWithDB(t *testing.T) {
    db := setupInMemoryDB(t) // setupInMemoryDB includes t.Cleanup(db.Close())
    // ... test logic ...
}

// Or for a suite of tests that share a DB, but still cleaned up
func TestMain(m *testing.M) {
    // setup global resources like a shared in-memory DB if truly needed for performance
    // db := setupSharedInMemoryDB()
    // defer db.Close() // Ensure it's closed when TestMain exits

    exitCode := m.Run() // Run all tests
    // additional cleanup if necessary
    os.Exit(exitCode)
}

golang-migrate/migrate

go test -p N

TestMain