Modules & Packages — Find the Bug¶

// package order
package order

import "shop/payment"

type Order struct {
    ID    string
    Total int
}

func (o *Order) Pay() error {
    return payment.Process(o)
}

// package payment
package payment

import "shop/order"   // <-- back-edge

func Process(o *order.Order) error {
    if o.Total <= 0 {
        return fmt.Errorf("order %s has non-positive total", o.ID)
    }
    // ... charge ...
    return nil
}

// package httpclient
package httpclient

import "net/http"

// Shared default client, exported for convenience.
var Default = &http.Client{}

func Get(url string) (*http.Response, error) {
    return Default.Get(url)
}

// package analytics   (background batch jobs, long timeouts OK)
package analytics

import "myapp/httpclient"

func init() {
    httpclient.Default.Timeout = 5 * time.Minute   // batch jobs are slow
}

// package checkout   (user-facing, must be snappy)
package checkout

import "myapp/httpclient"

func Charge(url string) error {
    _, err := httpclient.Get(url)   // expects a fast, ~2s timeout
    return err
}

// package cache
package cache

import "time"

// entry is meant to be private bookkeeping. But it's returned...
type entry struct {
    value     []byte
    expiresAt time.Time
}

// Get returns the raw entry "for efficiency".
func (c *Cache) GetEntry(key string) (*entry, bool) {   // (!) leaks *entry
    e, ok := c.m[key]
    return e, ok
}

// package handler   (a different package, a different team)
package handler

import "myapp/cache"

func serve(c *cache.Cache, key string) []byte {
    e, ok := c.GetEntry(key)
    if !ok {
        return nil
    }
    e.expiresAt = e.expiresAt.Add(time.Hour)   // (!) mutates cache internals
    return e.value
}

// package config
package config

var Settings = load()   // package-level var initializer

func load() map[string]string {
    return map[string]string{
        "region": os.Getenv("REGION"),   // read at package-init time
    }
}

// package metrics
package metrics

import "myapp/config"

// Package-level var: initialized when `metrics` is initialized.
var client = newClient(config.Settings["region"])

func newClient(region string) *Client {
    if region == "" {
        region = "us-east-1"   // fallback baked in at init
    }
    return &Client{region: region}
}

// package main
package main

import (
    "os"
    "myapp/metrics"
)

func main() {
    os.Setenv("REGION", "eu-west-1")   // (!) set AFTER imports are initialized
    metrics.Report("startup")          // already pinned to the wrong region
}

// module github.com/acme/sdk    (our public SDK)
// go.mod requires github.com/uuid/uuid v1.2.0
package sdk

import "github.com/uuid/uuid"

// We re-export the third-party UUID type in our PUBLIC signature.
type Event struct {
    ID   uuid.UUID   // (!) a transitive dependency's type in our public API
    Name string
}

func NewEvent(name string) Event {
    return Event{ID: uuid.New(), Name: name}
}

// downstream app
// go.mod requires:
//   github.com/acme/sdk     v1.0.0   (which needs uuid v1.2.0)
//   github.com/uuid/uuid    v2.0.0   (app uses v2 directly)
package main

import (
    "github.com/acme/sdk"
    "github.com/uuid/uuid"   // app's own, at v2
)

func main() {
    e := sdk.NewEvent("login")
    var id uuid.UUID = e.ID   // (!) assigning sdk's uuid.UUID to app's uuid.UUID
    _ = id
}