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 testfindetTestXxx(t *testing.T),BenchmarkXxx,FuzzXxxundExampleXxxvon selbst. Kein Framework nötig. - Table-driven: ein Slice von Testfällen plus eine
Schleife;
t.Runmacht daraus benannte Subtests, die du einzeln starten kannst. - Golden Files halten erwartete Ausgaben in
testdata/;-updateschreibt 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/semverErwartet:
? 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.goErwartet:
--- 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/semverErwartet:
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/semverErwartet:
=== 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/semverErwartet:
--- 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/semverErwartet:
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/semverErwartet (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/semverErwartet (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/semverErwartet:
--- 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/semverErwartet:
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-fuzztimeauf 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
-updateist ein ungeprüftes Approval. - Benchmarks nur auf ruhiger Hardware vergleichen; für belastbare
Aussagen mehrere Läufe mit
-count=10undbenchstatausgolang.org/x/perf. - Zum Thema Versionen: Für Go-Module gilt
golang.org/x/mod/semver, für Helm-Charts und Kubernetes-Tools oftgithub.com/Masterminds/semvermit Constraints wie>=1.28 <1.31. Eigene Implementierungen nur, wenn die Regeln wirklich anders sind.