Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 4: Testing – semver

Ziel: Ein semver-Tool bauen, das Versionen nach semver.org vergleicht, sortiert und hochzählt – abgesichert mit Table-Tests, Subtests, Examples, Golden Files, Fuzzing, Benchmarks und Coverage · Dauer: ca. 150 min · Voraussetzung: Tag 3

Briefing

  • Tests liegen neben dem Code in *_test.go; go test findet TestXxx(t *testing.T), BenchmarkXxx, FuzzXxx und ExampleXxx von selbst. Kein Framework nötig.
  • Table-driven: ein Slice von Testfällen plus eine Schleife; t.Run macht daraus benannte Subtests, die du einzeln starten kannst.
  • Golden Files halten erwartete Ausgaben in testdata/; -update schreibt sie neu.
  • Fuzzing erzeugt Eingaben, an die du nie gedacht hättest; Funde landen als Regressionstest in testdata/fuzz/.
  • Semver-Regeln, die du testest: 1.10.0 > 1.2.0, 1.0.0-rc.1 < 1.0.0, beta.11 > beta.2, Build-Metadaten (+…) zählen nicht.
 internal/semver                          cmd/semver
 semver.go   Parse, String      ◄──┐      main.go       run(args, stdin)
 compare.go  Compare, Sort         │      main_test.go  TestRun, TestSortGolden
 bump.go     Bump                  │      testdata/     sort.input, sort.golden
 *_test.go   Table, Example, Fuzz, Bench  ──► go test -run / -fuzz / -bench / -cover

Drill 1: Parse und String

mkdir -p ~/go-lab/tag04-semver && cd ~/go-lab/tag04-semver
go mod init example.com/semver
mkdir -p cmd/semver internal/semver
cat > internal/semver/semver.go <<'EOF'
// Package semver parst, vergleicht und erhöht Versionen nach semver.org 2.0.0.
package semver

import (
    "errors"
    "fmt"
    "strconv"
    "strings"
)

// ErrInvalid meldet eine ungültige Version.
var ErrInvalid = errors.New("ungültige Version")

// Version ist eine semantische Version wie v1.4.2-rc.1+build.7.
type Version struct {
    Major, Minor, Patch int
    Pre                 []string // Prerelease, z. B. ["rc", "1"]
    Build               string   // Build-Metadaten, zählen beim Vergleich nicht
    V                   bool     // mit führendem "v" geschrieben
}

// Parse zerlegt s. Das führende "v" ist optional.
func Parse(s string) (Version, error) {
    var v Version
    rest, hasV := strings.CutPrefix(s, "v")
    v.V = hasV
    rest, build, hasBuild := strings.Cut(rest, "+")
    core, pre, hasPre := strings.Cut(rest, "-")

    parts := strings.Split(core, ".")
    if len(parts) != 3 {
        return Version{}, fmt.Errorf("%w %q: brauche MAJOR.MINOR.PATCH", ErrInvalid, s)
    }
    nums := [3]*int{&v.Major, &v.Minor, &v.Patch}
    for i, p := range parts {
        n, err := number(p)
        if err != nil {
            return Version{}, fmt.Errorf("%w %q: %v", ErrInvalid, s, err)
        }
        *nums[i] = n
    }
    if hasPre {
        v.Pre = strings.Split(pre, ".")
        for _, id := range v.Pre {
            if err := identifier(id); err != nil {
                return Version{}, fmt.Errorf("%w %q: %v", ErrInvalid, s, err)
            }
        }
    }
    if hasBuild {
        for id := range strings.SplitSeq(build, ".") {
            if id == "" || strings.Trim(id, idChars) != "" {
                return Version{}, fmt.Errorf("%w %q: Build %q", ErrInvalid, s, id)
            }
        }
        v.Build = build
    }
    return v, nil
}

const idChars = "0123456789" +
    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-"

// number prüft eine Zahl ohne führende Nullen.
func number(s string) (int, error) {
    if s == "" || strings.Trim(s, "0123456789") != "" {
        return 0, fmt.Errorf("%q ist keine Zahl", s)
    }
    if len(s) > 1 && s[0] == '0' {
        return 0, fmt.Errorf("%q hat führende Null", s)
    }
    return strconv.Atoi(s)
}

// identifier prüft einen Prerelease-Teil wie "rc" oder "1".
func identifier(id string) error {
    if id == "" || strings.Trim(id, idChars) != "" {
        return fmt.Errorf("prerelease %q ungültig", id)
    }
    if isNum(id) && len(id) > 1 && id[0] == '0' {
        return fmt.Errorf("prerelease %q hat führende Null", id)
    }
    return nil
}

func isNum(s string) bool { return strings.Trim(s, "0123456789") == "" }

// String setzt die Version wieder zusammen.
func (v Version) String() string {
    s := fmt.Sprintf("%d.%d.%d", v.Major, v.Minor, v.Patch)
    if v.V {
        s = "v" + s
    }
    if len(v.Pre) > 0 {
        s += "-" + strings.Join(v.Pre, ".")
    }
    if v.Build != "" {
        s += "+" + v.Build
    }
    return s
}
EOF
go vet ./...

Erwartet:

go: creating new go.mod: module example.com/semver

Warum? strings.Cut zerlegt an der ersten Fundstelle und sagt dir mit dem dritten Rückgabewert, ob es den Trenner gab – damit sind + (Build) und - (Prerelease) sauber getrennt. nums ist ein Array aus Pointern auf die drei Felder, so füllt eine Schleife Major, Minor und Patch. strings.SplitSeq (Go 1.24) liefert einen Iterator statt eines Slices; go fix schlägt das selbst vor.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Der erste Table-Test

cat > internal/semver/semver_test.go <<'EOF'
package semver

import (
    "errors"
    "reflect"
    "testing"
)

func TestParse(t *testing.T) {
    tests := []struct {
        in      string
        want    Version
        wantErr bool
    }{
        {in: "1.2.3", want: Version{Major: 1, Minor: 2, Patch: 3}},
        {in: "v0.10.0", want: Version{Minor: 10, V: true}},
        {in: "1.0.0-rc.1", want: Version{Major: 1, Pre: []string{"rc", "1"}}},
        {in: "1.0.0+git.abc", want: Version{Major: 1, Build: "git.abc"}},
        {in: "1.2", wantErr: true},
        {in: "1.02.3", wantErr: true},
        {in: "1.2.3-", wantErr: true},
        {in: "1.2.3-rc..1", wantErr: true},
        {in: "1.2.3-01", wantErr: true},
        {in: "1.2.3+", wantErr: true},
        {in: "x.y.z", wantErr: true},
    }
    for _, tt := range tests {
        got, err := Parse(tt.in)
        if tt.wantErr {
            if !errors.Is(err, ErrInvalid) {
                t.Errorf("Parse(%q) err = %v, will ErrInvalid", tt.in, err)
            }
            continue
        }
        if err != nil {
            t.Errorf("Parse(%q) unerwarteter Fehler: %v", tt.in, err)
            continue
        }
        if !reflect.DeepEqual(got, tt.want) {
            t.Errorf("Parse(%q)\n got: %+v\nwant: %+v", tt.in, got, tt.want)
        }
    }
}
EOF
go test ./...
go test -v -run TestParse ./internal/semver

Erwartet:

?       example.com/semver/cmd/semver   [no test files]
ok      example.com/semver/internal/semver  0.164s
=== RUN   TestParse
--- PASS: TestParse (0.00s)
PASS
ok      example.com/semver/internal/semver  0.129s

Jetzt absichtlich kaputt machen – du willst wissen, wie ein Fehlschlag aussieht:

perl -pi -e 's/Minor: 2, Patch: 3\}/Minor: 2, Patch: 4}/' internal/semver/semver_test.go
go test ./internal/semver
perl -pi -e 's/Minor: 2, Patch: 4\}/Minor: 2, Patch: 3}/' internal/semver/semver_test.go

Erwartet:

--- FAIL: TestParse (0.00s)
    semver_test.go:40: Parse("1.2.3")
         got: 1.2.3
        want: 1.2.4
FAIL
FAIL    example.com/semver/internal/semver  0.166s
FAIL

Warum? Die Meldung nennt Datei, Zeile, Eingabe, Ist und Soll – so sollten deine Testmeldungen immer aussehen. %+v nutzt die Methode String(), weil Version damit fmt.Stringer erfüllt (Interfaces, Tag 2). t.Errorf meldet und macht weiter, t.Fatalf bricht den Test ab. reflect.DeepEqual vergleicht auch Slices und verschachtelte Structs.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Compare, Bump und Subtests

cat > internal/semver/compare.go <<'EOF'
package semver

import (
    "cmp"
    "slices"
)

// Compare liefert -1, 0 oder +1 – passend für slices.SortFunc.
func Compare(a, b Version) int {
    if c := cmp.Or(
        cmp.Compare(a.Major, b.Major),
        cmp.Compare(a.Minor, b.Minor),
        cmp.Compare(a.Patch, b.Patch),
    ); c != 0 {
        return c
    }
    // Ohne Prerelease ist größer: 1.0.0-rc.1 < 1.0.0
    switch {
    case len(a.Pre) == 0 && len(b.Pre) == 0:
        return 0
    case len(a.Pre) == 0:
        return 1
    case len(b.Pre) == 0:
        return -1
    }
    for i := range min(len(a.Pre), len(b.Pre)) {
        if c := compareID(a.Pre[i], b.Pre[i]); c != 0 {
            return c
        }
    }
    return cmp.Compare(len(a.Pre), len(b.Pre)) // rc < rc.1
}

// compareID: Zahlen numerisch, Zahlen < Text, Text nach ASCII.
func compareID(a, b string) int {
    an, bn := isNum(a), isNum(b)
    switch {
    case an && bn: // ohne führende Nullen: kürzer = kleiner, kein Überlauf
        return cmp.Or(cmp.Compare(len(a), len(b)), cmp.Compare(a, b))
    case an:
        return -1
    case bn:
        return 1
    }
    return cmp.Compare(a, b)
}

// Sort sortiert vs aufsteigend.
func Sort(vs []Version) { slices.SortStableFunc(vs, Compare) }
EOF
cat > internal/semver/bump.go <<'EOF'
package semver

import "fmt"

// Bump erhöht part ("major", "minor" oder "patch") wie npm und Cargo:
// Eine Prerelease wird zuerst "fertig", 1.3.0-rc.1 +minor = 1.3.0.
func Bump(v Version, part string) (Version, error) {
    pre := len(v.Pre) > 0
    switch part {
    case "major":
        if !pre || v.Minor != 0 || v.Patch != 0 {
            v.Major, v.Minor, v.Patch = v.Major+1, 0, 0
        }
    case "minor":
        if !pre || v.Patch != 0 {
            v.Minor, v.Patch = v.Minor+1, 0
        }
    case "patch":
        if !pre {
            v.Patch++
        }
    default:
        return v, fmt.Errorf("unbekannter Teil %q (major, minor, patch)", part)
    }
    v.Pre, v.Build = nil, ""
    return v, nil
}
EOF
cat > internal/semver/compare_test.go <<'EOF'
package semver

import "testing"

// mustParse ist ein Test-Helfer: t.Helper() lässt Fehler beim Aufrufer zeigen.
func mustParse(t *testing.T, s string) Version {
    t.Helper()
    v, err := Parse(s)
    if err != nil {
        t.Fatalf("Parse(%q): %v", s, err)
    }
    return v
}

func TestCompare(t *testing.T) {
    tests := []struct {
        a, b string
        want int
    }{
        {"1.2.3", "1.2.3", 0},
        {"1.2.3", "1.10.0", -1},
        {"2.0.0", "1.99.99", 1},
        {"1.0.0-rc.1", "1.0.0", -1},
        {"1.0.0-alpha", "1.0.0-alpha.1", -1},
        {"1.0.0-alpha.beta", "1.0.0-beta", -1},
        {"1.0.0-beta.2", "1.0.0-beta.11", -1},
        {"1.0.0-1", "1.0.0-alpha", -1},
        {"1.0.0+build.1", "1.0.0+build.2", 0},
        {"v1.0.0", "1.0.0", 0},
    }
    for _, tt := range tests {
        t.Run(tt.a+"_vs_"+tt.b, func(t *testing.T) {
            a, b := mustParse(t, tt.a), mustParse(t, tt.b)
            if got := Compare(a, b); got != tt.want {
                t.Errorf("Compare = %d, will %d", got, tt.want)
            }
            if got := Compare(b, a); got != -tt.want {
                t.Errorf("umgekehrt = %d, will %d", got, -tt.want)
            }
        })
    }
}

func TestBump(t *testing.T) {
    tests := []struct{ in, part, want string }{
        {"1.2.3", "patch", "1.2.4"},
        {"1.2.3", "minor", "1.3.0"},
        {"v1.2.3", "major", "v2.0.0"},
        {"1.2.3-rc.1", "patch", "1.2.3"},
        {"1.3.0-rc.1", "minor", "1.3.0"},
        {"1.3.1-rc.1", "minor", "1.4.0"},
        {"2.0.0-beta", "major", "2.0.0"},
        {"1.2.3+git.abc", "patch", "1.2.4"},
    }
    for _, tt := range tests {
        t.Run(tt.in+"_"+tt.part, func(t *testing.T) {
            got, err := Bump(mustParse(t, tt.in), tt.part)
            if err != nil {
                t.Fatal(err)
            }
            if got.String() != tt.want {
                t.Errorf("Bump = %s, will %s", got, tt.want)
            }
        })
    }
    if _, err := Bump(Version{}, "micro"); err == nil {
        t.Error("Bump(micro) ohne Fehler")
    }
}
EOF
go test ./internal/semver
go test -v -run 'TestCompare/beta' ./internal/semver

Erwartet:

ok      example.com/semver/internal/semver  0.164s
=== RUN   TestCompare
=== RUN   TestCompare/1.0.0-alpha.beta_vs_1.0.0-beta
=== RUN   TestCompare/1.0.0-beta.2_vs_1.0.0-beta.11
--- PASS: TestCompare (0.00s)
    --- PASS: TestCompare/1.0.0-alpha.beta_vs_1.0.0-beta (0.00s)
    --- PASS: TestCompare/1.0.0-beta.2_vs_1.0.0-beta.11 (0.00s)
PASS
ok      example.com/semver/internal/semver  0.176s

Warum? -run nimmt eine Regex pro Ebene, getrennt durch / – TestCompare/beta startet nur die Subtests mit „beta” im Namen. Jeder Fall prüft auch die Gegenrichtung: Ein Vergleich, der nicht antisymmetrisch ist, macht jede Sortierung kaputt. mustParse ruft t.Helper(), damit ein Fehler die Zeile im Test zeigt, nicht die im Helfer. Numerische Prerelease-Teile vergleicht compareID über ihre Länge – so läuft auch beta.99999999999999999999 nicht über.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Examples – Doku, die getestet wird

cat > internal/semver/example_test.go <<'EOF'
package semver_test

import (
    "fmt"

    "example.com/semver/internal/semver"
)

// Beispiele sind Doku UND Test: go test vergleicht die Output-Zeilen.
func ExampleBump() {
    v, _ := semver.Parse("v1.4.2")
    next, _ := semver.Bump(v, "minor")
    fmt.Println(next)
    // Output: v1.5.0
}

func ExampleSort() {
    var vs []semver.Version
    for _, s := range []string{"1.10.0", "1.2.0", "1.2.0-rc.1"} {
        v, _ := semver.Parse(s)
        vs = append(vs, v)
    }
    semver.Sort(vs)
    fmt.Println(vs)
    // Output: [1.2.0-rc.1 1.2.0 1.10.0]
}
EOF
go test -v -run Example ./internal/semver

Erwartet:

=== RUN   ExampleBump
--- PASS: ExampleBump (0.00s)
=== RUN   ExampleSort
--- PASS: ExampleSort (0.00s)
PASS
ok      example.com/semver/internal/semver  0.163s

Warum? go test vergleicht alles, was ein Example ausgibt, mit dem // Output:-Kommentar. go doc und pkg.go.dev zeigen dieselben Beispiele als Doku – sie können also nie veralten. Das Paket semver_test testet von außen, wie ein echter Nutzer: nur exportierte Namen.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Das CLI und Golden Files

main bekommt eine Funktion run, die nichts von os.Args, os.Stdin oder os.Exit weiß – damit ist das ganze Tool testbar:

cat > cmd/semver/main.go <<'EOF'
// semver vergleicht, sortiert und erhöht Versionen nach semver.org.
// Tag 4 aus "Go zum Anfassen".
package main

import (
    "bufio"
    "errors"
    "fmt"
    "io"
    "os"
    "strings"

    "example.com/semver/internal/semver"
)

const usage = `Aufruf:
  semver compare A B         gibt A<B, A=B oder A>B aus
  semver bump PART VERSION   PART: major, minor, patch
  semver sort                sortiert Versionen von stdin`

var errUsage = errors.New("falscher Aufruf")

func main() {
    out, err := run(os.Args[1:], os.Stdin)
    fmt.Print(out)
    switch {
    case errors.Is(err, errUsage):
        fmt.Fprintln(os.Stderr, usage)
        os.Exit(2)
    case err != nil:
        fmt.Fprintln(os.Stderr, "semver:", err)
        os.Exit(1)
    }
}

// run ist main ohne os.*: Argumente und stdin rein, Ausgabe und Fehler raus.
// So können Tests das ganze Tool aufrufen.
func run(args []string, stdin io.Reader) (string, error) {
    if len(args) == 0 {
        return "", errUsage
    }
    switch cmd := args[0]; {
    case cmd == "compare" && len(args) == 3:
        a, err := semver.Parse(args[1])
        if err != nil {
            return "", err
        }
        b, err := semver.Parse(args[2])
        if err != nil {
            return "", err
        }
        op := [...]string{"<", "=", ">"}[semver.Compare(a, b)+1]
        return fmt.Sprintf("%s %s %s\n", a, op, b), nil
    case cmd == "bump" && len(args) == 3:
        v, err := semver.Parse(args[2])
        if err != nil {
            return "", err
        }
        v, err = semver.Bump(v, args[1])
        if err != nil {
            return "", err
        }
        return v.String() + "\n", nil
    case cmd == "sort" && len(args) == 1:
        return sortVersions(stdin)
    }
    return "", errUsage
}

// sortVersions liest eine Version pro Zeile; Leerzeilen werden übersprungen.
func sortVersions(r io.Reader) (string, error) {
    var vs []semver.Version
    sc := bufio.NewScanner(r)
    for sc.Scan() {
        line := strings.TrimSpace(sc.Text())
        if line == "" {
            continue
        }
        v, err := semver.Parse(line)
        if err != nil {
            return "", err
        }
        vs = append(vs, v)
    }
    if err := sc.Err(); err != nil {
        return "", err
    }
    semver.Sort(vs)
    var b strings.Builder
    for _, v := range vs {
        b.WriteString(v.String() + "\n")
    }
    return b.String(), nil
}
EOF
mkdir -p cmd/semver/testdata
cat > cmd/semver/testdata/sort.input <<'EOF'
1.0.0
1.0.0-rc.1
v0.9.12
1.0.0-beta.11
1.0.0-alpha

1.0.0-beta.2
1.0.0-alpha.beta
1.0.0-alpha.1
0.10.0
1.0.0-beta
EOF
cat > cmd/semver/main_test.go <<'EOF'
package main

import (
    "errors"
    "flag"
    "os"
    "path/filepath"
    "strings"
    "testing"

    "example.com/semver/internal/semver"
)

var update = flag.Bool("update", false, "Golden Files neu schreiben")

func TestSortGolden(t *testing.T) {
    in, err := os.Open(filepath.Join("testdata", "sort.input"))
    if err != nil {
        t.Fatal(err)
    }
    defer in.Close() //nolint:errcheck // nur gelesen

    got, err := run([]string{"sort"}, in)
    if err != nil {
        t.Fatal(err)
    }
    golden := filepath.Join("testdata", "sort.golden")
    if *update {
        if err := os.WriteFile(golden, []byte(got), 0o644); err != nil {
            t.Fatal(err)
        }
    }
    want, err := os.ReadFile(golden)
    if err != nil {
        t.Fatal(err)
    }
    if got != string(want) {
        t.Errorf("Ausgabe weicht ab:\n%s\nwill (%s):\n%s", got, golden, want)
    }
}

func TestRun(t *testing.T) {
    tests := []struct {
        name    string
        args    []string
        want    string
        wantErr error
    }{
        {"compare", []string{"compare", "1.2.3", "1.10.0"}, "1.2.3 < 1.10.0\n", nil},
        {"bump", []string{"bump", "minor", "v1.2.3"}, "v1.3.0\n", nil},
        {"leer", nil, "", errUsage},
        {"zu wenig", []string{"compare", "1.0.0"}, "", errUsage},
        {"kaputt", []string{"bump", "patch", "1.x.0"}, "", semver.ErrInvalid},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got, err := run(tt.args, strings.NewReader(""))
            if !errors.Is(err, tt.wantErr) { // errors.Is(nil, nil) ist true
                t.Fatalf("err = %v, will %v", err, tt.wantErr)
            }
            if got != tt.want {
                t.Errorf("Ausgabe = %q, will %q", got, tt.want)
            }
        })
    }
}
EOF
go test ./cmd/semver

Erwartet:

--- FAIL: TestSortGolden (0.00s)
    main_test.go:35: open testdata/sort.golden: no such file or directory
FAIL
FAIL    example.com/semver/cmd/semver   0.242s
FAIL

Die Golden-Datei gibt es noch nicht. Lass sie erzeugen, prüf sie mit eigenen Augen und teste erneut:

go test ./cmd/semver -run Golden -update
cat cmd/semver/testdata/sort.golden
go test ./cmd/semver

Erwartet:

ok      example.com/semver/cmd/semver   0.129s
v0.9.12
0.10.0
1.0.0-alpha
1.0.0-alpha.1
1.0.0-alpha.beta
1.0.0-beta
1.0.0-beta.2
1.0.0-beta.11
1.0.0-rc.1
1.0.0
ok      example.com/semver/cmd/semver   0.140s

Warum? Die Reihenfolge alpha < alpha.1 < alpha.beta < beta < beta.2 < beta.11 < rc.1 < 1.0.0 ist exakt das Beispiel aus der Spezifikation auf semver.org. Golden Files lohnen sich für längere Ausgaben (Reports, generiertes YAML): Ändert sich die Ausgabe, zeigt der Diff im Git-Review genau, was. -update ist ein eigenes Test-Flag, definiert mit flag.Bool im Test. Go-Tests laufen immer im Ordner ihres Pakets, deshalb funktioniert der relative Pfad testdata/….

Fortschritt speichern? Kostenlos registrieren

Drill 6: Fuzzing – Eingaben, an die du nie denkst

Zwei Fuzz-Tests: Der erste prüft eine Eigenschaft (was Parse akzeptiert, gibt String unverändert zurück). Der zweite vergleicht differentiell mit golang.org/x/mod/semver, der Implementierung, die das Go-Tooling selbst nutzt:

go get golang.org/x/[email protected]
cat > internal/semver/fuzz_test.go <<'EOF'
package semver

import (
    "strings"
    "testing"

    xsemver "golang.org/x/mod/semver"
)

// FuzzParse: Was Parse akzeptiert, muss String() exakt zurückgeben.
func FuzzParse(f *testing.F) {
    for _, s := range []string{"1.2.3", "v1.0.0-rc.1+b.7", "0.0.0-0.a-b"} {
        f.Add(s) // Seed-Korpus
    }
    f.Fuzz(func(t *testing.T, s string) {
        v, err := Parse(s)
        if err != nil {
            return // ungültige Eingaben sind ok, nur kein Panic
        }
        if got := v.String(); got != s {
            t.Errorf("Parse(%q).String() = %q", s, got)
        }
        if Compare(v, v) != 0 {
            t.Errorf("Compare(%q, %q) != 0", s, s)
        }
    })
}

// FuzzCompare vergleicht mit golang.org/x/mod/semver (differentielles Fuzzing).
func FuzzCompare(f *testing.F) {
    f.Add("1.0.0-alpha.1", "1.0.0-alpha.beta")
    f.Add("1.0.0-beta.11", "1.0.0-beta.2")
    f.Fuzz(func(t *testing.T, a, b string) {
        va, errA := Parse(a)
        vb, errB := Parse(b)
        if errA != nil || errB != nil {
            return
        }
        ref := xsemver.Compare(withV(a), withV(b))
        if got := Compare(va, vb); got != ref {
            t.Errorf("Compare(%q, %q) = %d, x/mod sagt %d", a, b, got, ref)
        }
    })
}

func withV(s string) string { return "v" + strings.TrimPrefix(s, "v") }
EOF
go mod tidy
go test -run '^$' -fuzz '^FuzzParse$' -fuzztime 10s ./internal/semver

Erwartet (gekürzt, Zahlen variieren):

go: added golang.org/x/mod v0.42.0
fuzz: elapsed: 0s, gathering baseline coverage: 0/3 completed
fuzz: elapsed: 3s, execs: 144061 (48002/sec), new interesting: 98 (total: 101)
fuzz: elapsed: 6s, execs: 309666 (55213/sec), new interesting: 131 (total: 134)
fuzz: elapsed: 9s, execs: 508360 (66239/sec), new interesting: 150 (total: 153)
fuzz: elapsed: 11s, execs: 583914 (37592/sec), new interesting: 159 (total: 162)
PASS
ok      example.com/semver/internal/semver  11.386s

Nichts gefunden – gut. Damit du siehst, was Fuzzing leistet, schaltest du die Prüfung auf führende Nullen in Prerelease-Teilen ab (1.0.0-01 ist laut Spezifikation ungültig):

perl -pi -e 's/if isNum\(id\) &&/if false \&\&/' internal/semver/semver.go
go test -run '^$' -fuzz '^FuzzCompare$' -fuzztime 30s ./internal/semver

Erwartet (gekürzt; Eingabe und Hash weichen bei dir ab):

fuzz: minimizing 63-byte failing input file
fuzz: elapsed: 0s, minimizing
--- FAIL: FuzzCompare (0.07s)
    --- FAIL: FuzzCompare (0.00s)
        fuzz_test.go:41: Compare("1.0.0-c.00", "0.0.0+0") = 1, x/mod sagt -1

    Failing input written to testdata/fuzz/FuzzCompare/2ec74667cff9214b
    To re-run:
    go test -run=FuzzCompare/2ec74667cff9214b
FAIL

In Millisekunden gefunden: 1.0.0-c.00 ist ungültig, dein Code hält es aber für eine Version und sortiert sie über 0.0.0. Prüfung wieder einschalten, Fund behalten:

perl -pi -e 's/if false &&/if isNum(id) \&\&/' internal/semver/semver.go
go test -v -run FuzzCompare ./internal/semver | grep -- '--- PASS'
ls internal/semver/testdata/fuzz/FuzzCompare/

Erwartet:

--- PASS: FuzzCompare (0.00s)
    --- PASS: FuzzCompare/seed#0 (0.00s)
    --- PASS: FuzzCompare/seed#1 (0.00s)
    --- PASS: FuzzCompare/2ec74667cff9214b (0.00s)
2ec74667cff9214b

Warum? Ein normales go test führt Seeds und gespeicherte Funde aus – ohne -fuzz, also schnell genug für jede CI. Den Ordner testdata/fuzz/ committest du; er ist dein wachsender Regressionstest. Fuzzing selbst läuft nur auf einem Paket gleichzeitig und braucht -fuzz mit genau einem passenden Test.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Benchmarks, Coverage, Race

cat > internal/semver/bench_test.go <<'EOF'
package semver

import "testing"

func BenchmarkParse(b *testing.B) {
    for b.Loop() { // seit Go 1.24: misst nur den Schleifenrumpf
        if _, err := Parse("v1.42.7-rc.3+build.2026"); err != nil {
            b.Fatal(err)
        }
    }
}

func BenchmarkCompare(b *testing.B) {
    x, _ := Parse("1.0.0-beta.11")
    y, _ := Parse("1.0.0-beta.2")
    for b.Loop() {
        Compare(x, y)
    }
}
EOF
go test -run '^$' -bench . -benchmem ./internal/semver
go test -cover ./...
go test -coverprofile=cover.out ./internal/semver >/dev/null
go tool cover -func=cover.out | tail -4
go test -race -count=1 ./...

Erwartet (Zeiten hängen von deiner Hardware ab):

goos: darwin
goarch: arm64
pkg: example.com/semver/internal/semver
cpu: Apple M4
BenchmarkParse-10        1203819           922.0 ns/op       112 B/op          3 allocs/op
BenchmarkCompare-10     25468334            48.37 ns/op        0 B/op          0 allocs/op
PASS
ok      example.com/semver/internal/semver  2.494s
ok      example.com/semver/cmd/semver   0.137s  coverage: 72.7% of statements
ok      example.com/semver/internal/semver  0.264s  coverage: 100.0% of statements
example.com/semver/internal/semver/semver.go:76:    identifier  100.0%
example.com/semver/internal/semver/semver.go:86:    isNum       100.0%
example.com/semver/internal/semver/semver.go:89:    String      100.0%
total:                          (statements)    100.0%
ok      example.com/semver/cmd/semver   1.275s
ok      example.com/semver/internal/semver  1.149s

Warum? b.Loop() (seit Go 1.24) ersetzt das alte for i := 0; i < b.N; i++: Setup vor der Schleife wird nicht mitgemessen, und der Compiler darf den Aufruf nicht wegoptimieren. -benchmem zeigt Allokationen – oft der größere Hebel als CPU (Tag 13). 100 % Coverage heißt nur „jede Zeile lief einmal”, nicht „alles richtig” – dafür hast du Fuzzing. cmd/semver liegt bei 73 %, weil main selbst nicht getestet wird; genau deshalb steckt die Logik in run. -race findet Datenrennen, sobald Goroutines im Spiel sind (Tag 8); gewöhn dich jetzt daran.

Tipp: go tool cover -html=cover.out öffnet eine farbige Ansicht im Browser: grün getestet, rot ungetestet.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Das Tool ist fertig

cd ~/go-lab/tag04-semver
gofmt -l . && go vet ./... && ~/go-lab/bin/lint run ./...
go build -o bin/semver ./cmd/semver
./bin/semver compare 1.2.3 1.10.0
./bin/semver compare v1.0.0-rc.1 v1.0.0
./bin/semver bump minor v1.2.3
./bin/semver bump major 2.0.0-rc.1
printf 'v1.31.2\nv1.32.0-rc.1\nv1.32.0\nv1.31.10\n' > tags.txt
./bin/semver sort < tags.txt | tail -1
sort -V tags.txt | tail -1
./bin/semver compare 1.02.0 1.0.0; echo "exit=$?"
./bin/semver; echo "exit=$?"

Erwartet:

0 issues.
1.2.3 < 1.10.0
v1.0.0-rc.1 < v1.0.0
v1.3.0
2.0.0
v1.32.0
v1.32.0-rc.1
semver: ungültige Version "1.02.0": "02" hat führende Null
exit=1
Aufruf:
  semver compare A B         gibt A<B, A=B oder A>B aus
  semver bump PART VERSION   PART: major, minor, patch
  semver sort                sortiert Versionen von stdin
exit=2

Siehst du die beiden v1.32.0-Zeilen? sort -V hält v1.32.0-rc.1 für neuer als v1.32.0 – nach semver ist es umgekehrt. Genau für solche Fälle lohnt sich ein eigenes, getestetes Tool. In Release-Skripten (Tag 14) liefert git tag | semver sort | tail -1 den letzten Tag, semver bump patch den nächsten.

Dein Modul:

tag04-semver/
├── cmd/semver/
│   ├── main.go, main_test.go
│   └── testdata/sort.input, sort.golden
├── internal/semver/
│   ├── semver.go, compare.go, bump.go
│   ├── semver_test.go, compare_test.go, example_test.go
│   ├── fuzz_test.go, bench_test.go
│   └── testdata/fuzz/FuzzCompare/…
├── go.mod
└── go.sum

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
cd ~/go-lab/tag04-semver
check "gofmt sauber" "test -z \"\$(gofmt -l .)\""
check "go vet" "go vet ./..."
check "golangci-lint" "~/go-lab/bin/lint run ./..."
check "Tests grün (mit Race)" "go test -race -count=1 ./..."
check "Golden File vorhanden" "test -s cmd/semver/testdata/sort.golden"
check "Fuzz-Fund gespeichert" "ls internal/semver/testdata/fuzz/FuzzCompare/*"
check "Coverage Paket 100 %" \
  "go test -cover ./internal/semver | grep -q 'coverage: 100.0%'"
check "kurzer Fuzz-Lauf" \
  "go test -run '^$' -fuzz '^FuzzParse$' -fuzztime 5s ./internal/semver"

Erwartet:

✔ gofmt sauber
✔ go vet
✔ golangci-lint
✔ Tests grün (mit Race)
✔ Golden File vorhanden
✔ Fuzz-Fund gespeichert
✔ Coverage Paket 100 %
✔ kurzer Fuzz-Lauf

Challenge

Schreib einen Fuzz-Test FuzzBump für die Eigenschaft „eine erhöhte Version ist immer größer als vorher” (Compare(next, v) == 1). Findet er etwas? Füg dann einen Seed hinzu, der an die Grenzen von int geht – und repariere, was er findet.

Hinweis: math.MaxInt ist auf deinem Mac 9223372036854775807, und Parse akzeptiert diese Zahl.

Lösung

cat > internal/semver/bump_fuzz_test.go <<'EOF'
package semver

import "testing"

// FuzzBump: Jede erhöhte Version muss größer sein als vorher.
func FuzzBump(f *testing.F) {
    f.Add("1.2.3", "minor")
    f.Add("2.0.0-rc.1", "major")
    f.Add("9223372036854775807.0.0", "major") // math.MaxInt
    f.Fuzz(func(t *testing.T, s, part string) {
        v, err := Parse(s)
        if err != nil {
            return
        }
        next, err := Bump(v, part)
        if err != nil {
            return // unbekannter Teil oder Überlauf
        }
        if Compare(next, v) != 1 {
            t.Errorf("Bump(%q, %q)\n= %q ist nicht größer", s, part, next)
        }
    })
}
EOF
go test -run FuzzBump ./internal/semver

Erwartet:

--- FAIL: FuzzBump (0.00s)
    --- FAIL: FuzzBump/seed#2 (0.00s)
        bump_fuzz_test.go:20: Bump("9223372036854775807.0.0", "major")
            = "-9223372036854775808.0.0" ist nicht größer
FAIL

Ohne den dritten Seed läuft der Fuzzer minutenlang ohne Fund – 19-stellige Zahlen errät er selten. Der Überlauf ist aber echt: Go-Integer laufen still über, ohne Panic. Die Reparatur: Die bisherige Funktion wird intern zu bump, das neue Bump prüft vorher – kein Aufrufer muss sich ändern:

perl -0pi -e 's/import "fmt"/import (\n\t"fmt"\n\t"math"\n)/' internal/semver/bump.go
perl -pi -e 's/^func Bump\(/func bump(/; s/^\/\/ Bump erh/\/\/ bump erh/' \
  internal/semver/bump.go
cat >> internal/semver/bump.go <<'EOF'

// Bump erhöht wie bump, verweigert aber Teile, die überlaufen würden.
func Bump(v Version, part string) (Version, error) {
    if max(v.Major, v.Minor, v.Patch) == math.MaxInt {
        return v, fmt.Errorf("%w: %s läuft über", ErrInvalid, v)
    }
    return bump(v, part)
}
EOF
gofmt -l . ; go test ./internal/semver

Erwartet:

ok      example.com/semver/internal/semver  0.171s

Seeds sind also kein Beiwerk: Grenzwerte (0, leere Strings, MaxInt, sehr lange Eingaben) gehören immer in f.Add.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • In CI: go test -race -count=1 ./... bei jedem Push, Fuzzing nachts mit längerer -fuzztime auf einem eigenen Runner; neue Funde als PR mit dem Korpus-Eintrag.
  • Coverage-Ziele pro Paket statt global: 100 % für Parser und Geldberechnungen, deutlich weniger für Glue-Code. Coverage ist ein Hinweis, kein Qualitätsbeweis.
  • Golden Files im Review ernst nehmen: Ein blindes -update ist ein ungeprüftes Approval.
  • Benchmarks nur auf ruhiger Hardware vergleichen; für belastbare Aussagen mehrere Läufe mit -count=10 und benchstat aus golang.org/x/perf.
  • Zum Thema Versionen: Für Go-Module gilt golang.org/x/mod/semver, für Helm-Charts und Kubernetes-Tools oft github.com/Masterminds/semver mit Constraints wie >=1.28 <1.31. Eigene Implementierungen nur, wenn die Regeln wirklich anders sind.