Fail-Fast — Find the Bug¶

func CreateUser(ctx context.Context, db *sql.DB, req CreateUserRequest) (int64, error) {
    res, err := db.ExecContext(ctx,
        `INSERT INTO users (email, age) VALUES ($1, $2)`,
        req.Email, req.Age)
    if err != nil {
        return 0, err
    }
    if req.Age < 0 || req.Age > 150 {
        return 0, fmt.Errorf("invalid age: %d", req.Age)
    }
    if !strings.Contains(req.Email, "@") {
        return 0, fmt.Errorf("invalid email")
    }
    id, _ := res.LastInsertId()
    return id, nil
}

func loadConfig(path string) Config {
    data, _ := os.ReadFile(path)
    var cfg Config
    _ = json.Unmarshal(data, &cfg)
    return cfg
}

func main() {
    cfg := loadConfig("/etc/myapp/config.yaml")  // note: wrong extension
    server.Start(cfg)                            // starts with zero-value config
}

func ParsePort(s string) int {
    n, err := strconv.Atoi(s)
    if err != nil {
        return 0
    }
    return n
}

func main() {
    port := ParsePort(os.Getenv("PORT"))   // PORT unset, returns 0
    http.ListenAndServe(fmt.Sprintf(":%d", port), nil)
}

func parseAmount(s string) decimal.Decimal {
    d, err := decimal.NewFromString(s)
    if err != nil {
        panic(fmt.Sprintf("invalid amount: %s", s))
    }
    return d
}

func transferHandler(w http.ResponseWriter, r *http.Request) {
    amount := parseAmount(r.FormValue("amount"))
    // ... transfer logic
}

func parsePrice(s string) (float64, error) {
    p, err := strconv.ParseFloat(s, 64)
    if err != nil {
        return 0, err
    }
    return p, nil
}

func placeOrder(qty int, priceStr string) (Order, error) {
    price, err := parsePrice(priceStr)
    if err != nil { return Order{}, err }
    return Order{Total: float64(qty) * price}, nil
}

// caller sends priceStr="NaN" or "Inf" — both parse cleanly.

func generateReport(ctx context.Context, userID string) (*Report, error) {
    rows := db.QueryRowsLong(ctx, userID)        // 30s
    summary := summarizeMillions(rows)            // 10s of CPU
    chart := renderChart(summary)                 // 5s
    if err := ctx.Err(); err != nil {
        return nil, err
    }
    return &Report{Summary: summary, Chart: chart}, nil
}

func validate(req CreateUserRequest) error {
    if req.Email == "" {
        return errors.New("email is required")
    }
    if !strings.Contains(req.Email, "@") {
        return errors.New("invalid email")
    }
    if req.Age < 0 || req.Age > 150 {
        return errors.New("invalid age")
    }
    if len(req.Tags) > 10 {
        return errors.New("too many tags")
    }
    return nil
}

func createUserHandler(w http.ResponseWriter, r *http.Request) {
    var req CreateUserRequest
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "bad json", 400); return
    }
    if req.Age < 0 || req.Age > 150 {
        http.Error(w, "bad age", 400); return
    }
    // ... HTTP-side validation
    if err := db.InsertUser(r.Context(), req); err != nil {
        http.Error(w, "server error", 500); return
    }
}

// internal call path used by a CLI tool, an admin RPC, and a bulk import:
func ImportUser(ctx context.Context, req CreateUserRequest) error {
    return db.InsertUser(ctx, req)   // BUG: no validation
}

var emailRE = regexp.MustCompile(`.+@.+`)

func validateEmail(s string) error {
    if !emailRE.MatchString(s) {
        return fmt.Errorf("invalid email: %q", s)
    }
    return nil
}

func uploadFile(path string, data []byte) error {
    if _, err := os.Stat(path); err == nil {
        return fmt.Errorf("uploadFile: %q already exists", path)
    }
    return os.WriteFile(path, data, 0644)
}

type Config struct {
    Port     int    `json:"port"`
    LogLevel string `json:"log_level"`
}

func loadConfig(r io.Reader) (Config, error) {
    var c Config
    if err := json.NewDecoder(r).Decode(&c); err != nil {
        return Config{}, err
    }
    return c, nil
}

// config file:
// {"port": 8080, "loglevel": "debug"}
//                      ^^^^^^^^^^ silently ignored (typo: missing underscore)

func readUser(ctx context.Context, db *sql.DB, id string) (*User, error) {
    var u User
    err := db.QueryRowContext(ctx, "SELECT ... WHERE id = $1", id).Scan(&u.Name, &u.Email)
    if err == sql.ErrNoRows {
        return nil, ErrUserNotFound
    }
    if err != nil {
        return nil, fmt.Errorf("readUser: %w", err)
    }
    return &u, nil
}

func loadUser(ctx context.Context, id string) (*User, error) {
    u, err := db.ReadUser(ctx, id)
    if err != nil {
        return nil, fmt.Errorf("loadUser %s: %v", id, err)
    }
    return u, nil
}

// caller:
u, err := loadUser(ctx, id)
if errors.Is(err, sql.ErrNoRows) {       // never true
    return http.StatusNotFound
}

type Server struct {
    db       *sql.DB
    cache    *redis.Client
    listener net.Listener
}

func NewServer(cfg Config) (*Server, error) {
    s := &Server{}
    var err error
    s.db, err = sql.Open("postgres", cfg.DSN)
    if err != nil {
        return s, err
    }
    s.cache = redis.NewClient(&redis.Options{Addr: cfg.RedisAddr})
    if err := s.cache.Ping(context.Background()).Err(); err != nil {
        return s, err
    }
    s.listener, err = net.Listen("tcp", cfg.Addr)
    if err != nil {
        return s, err
    }
    return s, nil
}

// caller:
s, err := NewServer(cfg)
if err != nil {
    log.Printf("init: %v", err)
}
s.Run()  // BUG: caller often uses the half-built s despite err

func processJob(ctx context.Context, job Job) error {
    defer func() {
        if r := recover(); r != nil {
            log.Printf("job %s panicked: %v", job.ID, r)
        }
    }()
    if err := step1(ctx, job); err != nil { return err }
    if err := step2(ctx, job); err != nil { return err }
    return step3(ctx, job)
}

// caller:
if err := processJob(ctx, job); err != nil {
    log.Printf("retry: %v", err)
    queue.Retry(job)
}