Go Development Environment Best Practices¶

// internal/testing/testutil.go
package testing

import (
    "context"
    "database/sql"
    "testing"
    "time"

    "github.com/DATA-DOG/go-sqlmock"
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/require"
)

// TestDB creates a mock database for testing
func TestDB(t *testing.T) (*sql.DB, sqlmock.Sqlmock) {
    db, mock, err := sqlmock.New()
    require.NoError(t, err)

    t.Cleanup(func() {
        db.Close()
    })

    return db, mock
}

// TestContext creates a test context with timeout
func TestContext(t *testing.T) context.Context {
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    t.Cleanup(cancel)
    return ctx
}

// AssertNoError is a helper for common error assertions
func AssertNoError(t *testing.T, err error) {
    t.Helper()
    assert.NoError(t, err)
}

// AssertError is a helper for error assertions
func AssertError(t *testing.T, err error) {
    t.Helper()
    assert.Error(t, err)
}

// cmd/server/main.go
package main

import (
    "log"
    "net/http"
    _ "net/http/pprof"
    "os"
    "os/signal"
    "syscall"
)

func main() {
    // Enable pprof endpoints
    go func() {
        log.Println("Starting pprof server on :6060")
        log.Println(http.ListenAndServe("localhost:6060", nil))
    }()

    // Graceful shutdown
    c := make(chan os.Signal, 1)
    signal.Notify(c, os.Interrupt, syscall.SIGTERM)

    // Start your application
    // ...

    <-c
    log.Println("Shutting down gracefully...")
}

// internal/service/benchmark_test.go
package service

import (
    "testing"
)

func BenchmarkProcessData(b *testing.B) {
    service := NewService()
    data := generateTestData(1000)

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        service.ProcessData(data)
    }
}

func BenchmarkConcurrentProcess(b *testing.B) {
    service := NewService()
    data := generateTestData(1000)

    b.ResetTimer()
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            service.ProcessData(data)
        }
    })
}

// internal/config/config.go
package config

import (
    "os"
    "strconv"
    "time"
)

type Config struct {
    Server   ServerConfig
    Database DatabaseConfig
    Security SecurityConfig
}

type ServerConfig struct {
    Port         string
    ReadTimeout  time.Duration
    WriteTimeout time.Duration
}

type DatabaseConfig struct {
    Host     string
    Port     int
    Username string
    Password string
    SSLMode  string
}

type SecurityConfig struct {
    JWTSecret     string
    BcryptCost    int
    RateLimitRPS  int
}

func Load() (*Config, error) {
    return &Config{
        Server: ServerConfig{
            Port:         getEnv("SERVER_PORT", "8080"),
            ReadTimeout:  getDuration("SERVER_READ_TIMEOUT", 30*time.Second),
            WriteTimeout: getDuration("SERVER_WRITE_TIMEOUT", 30*time.Second),
        },
        Database: DatabaseConfig{
            Host:     getEnv("DB_HOST", "localhost"),
            Port:     getInt("DB_PORT", 5432),
            Username: getEnv("DB_USERNAME", "postgres"),
            Password: getEnv("DB_PASSWORD", ""),
            SSLMode:  getEnv("DB_SSL_MODE", "require"),
        },
        Security: SecurityConfig{
            JWTSecret:    getEnv("JWT_SECRET", ""),
            BcryptCost:   getInt("BCRYPT_COST", 12),
            RateLimitRPS: getInt("RATE_LIMIT_RPS", 100),
        },
    }, nil
}

func getEnv(key, defaultValue string) string {
    if value := os.Getenv(key); value != "" {
        return value
    }
    return defaultValue
}

func getInt(key string, defaultValue int) int {
    if value := os.Getenv(key); value != "" {
        if intValue, err := strconv.Atoi(value); err == nil {
            return intValue
        }
    }
    return defaultValue
}

func getDuration(key string, defaultValue time.Duration) time.Duration {
    if value := os.Getenv(key); value != "" {
        if duration, err := time.ParseDuration(value); err == nil {
            return duration
        }
    }
    return defaultValue
}