Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 6: Tests mit envtest

Ziel: Eine Testsuite, die den echten Reconciler gegen einen echten API-Server prüft – mit Eventually, Consistently, Tabellen, Unit-Tests ohne Cluster und Coverage, CI-tauglich · Dauer: ca. 120 min · Voraussetzung: Tag 5

Briefing

  • envtest startet pro Suite etcd + kube-apiserver; der Manager mit deinem Reconciler läuft als Goroutine daneben.
  • Tests prüfen Ergebnisse, nicht Aufrufe: Eventually wartet, bis der Cluster den erwarteten Zustand hat. Kein time.Sleep.
  • Jede Spec bekommt einen eigenen Namespace – keine Abhängigkeiten zwischen Tests, Reihenfolge egal (Ginkgo würfelt sie).
  • Was ohne API-Server geht (Mutate-Funktionen, Fehlerpfade), testest du schneller mit Go-Tabellen und dem fake client.
go test ./internal/controller/
  |- TestControllers (Ginkgo)  -> envtest: etcd + kube-apiserver + CRDs
  |     |- Manager + StaticSiteReconciler (Goroutine)
  |     +- Specs: k8sClient (ohne Cache) + Eventually/Consistently
  |- TestMutateDeployment       -> reine Go-Tabelle, kein Cluster
  +- TestReconcileContentMissing -> fake client + FakeRecorder

Drill 1: Ausgangslage

Für Tests brauchst du kein envtest-up – die Suite startet ihre eigene Control Plane. Terminal 1 genügt:

source ~/op-lab/env.sh
cp -r ~/op-lab/tag05-site-operator ~/op-lab/tag06-site-operator
cd ~/op-lab/tag06-site-operator
rm -f lab/columns.txt lab/recorder.txt lab/check.sh
go test ./internal/... -count=1 -v -ginkgo.v -ginkgo.no-color 2>&1 \
  | grep -E '^(StaticSite|Ran [0-9]|SUCCESS)'

Erwartet (gekürzt):

StaticSite Controller When reconciling a resource should successfully reconcile ...
StaticSite API setzt Defaults im API-Server
StaticSite API lehnt replicas > 10 ab
StaticSite API – contentFrom verlangt configMapRef.name
Ran 4 of 4 Specs in 5.541 seconds
SUCCESS! -- 4 Passed | 0 Failed | 0 Pending | 0 Skipped

Der Kubebuilder-Test ruft Reconcile direkt auf und prüft nur „kein Fehler”. Heute ersetzt du ihn durch Specs, die das Verhalten prüfen.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Die Suite startet den Manager

k8sClient liest direkt vom API-Server (kein Cache) – so sieht der Test immer den aktuellen Stand. Der Reconciler bekommt den gecachten Client des Managers, wie in Produktion.

cat > internal/controller/suite_test.go <<'EOF'
package controller

import (
    "context"
    "path/filepath"
    "testing"
    "time"

    . "github.com/onsi/ginkgo/v2"
    . "github.com/onsi/gomega"
    "k8s.io/client-go/kubernetes/scheme"
    ctrl "sigs.k8s.io/controller-runtime"
    "sigs.k8s.io/controller-runtime/pkg/client"
    "sigs.k8s.io/controller-runtime/pkg/envtest"
    logf "sigs.k8s.io/controller-runtime/pkg/log"
    "sigs.k8s.io/controller-runtime/pkg/log/zap"
    metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server"

    webv1alpha1 "example.com/site-operator/api/v1alpha1"
)

var (
    ctx       context.Context
    cancel    context.CancelFunc
    testEnv   *envtest.Environment
    k8sClient client.Client // direkt, ohne Cache: sieht immer den aktuellen Stand
)

func TestControllers(t *testing.T) {
    RegisterFailHandler(Fail)
    RunSpecs(t, "Controller Suite")
}

var _ = BeforeSuite(func() {
    logf.SetLogger(zap.New(zap.WriteTo(GinkgoWriter), zap.UseDevMode(true)))
    SetDefaultEventuallyTimeout(10 * time.Second)
    SetDefaultEventuallyPollingInterval(100 * time.Millisecond)
    // Mit WithContext(ctx) gilt der Default-Timeout sonst nicht – Test hinge ewig.
    EnforceDefaultTimeoutsWhenUsingContexts()
    ctx, cancel = context.WithCancel(context.Background())
    Expect(webv1alpha1.AddToScheme(scheme.Scheme)).To(Succeed())

    By("envtest starten (Binaries aus KUBEBUILDER_ASSETS)")
    testEnv = &envtest.Environment{
        CRDDirectoryPaths: []string{
            filepath.Join("..", "..", "config", "crd", "bases"),
        },
        ErrorIfCRDPathMissing: true,
    }
    cfg, err := testEnv.Start()
    Expect(err).NotTo(HaveOccurred())
    k8sClient, err = client.New(cfg, client.Options{Scheme: scheme.Scheme})
    Expect(err).NotTo(HaveOccurred())

    By("Manager mit dem echten Reconciler starten")
    mgr, err := ctrl.NewManager(cfg, ctrl.Options{
        Scheme:  scheme.Scheme,
        Metrics: metricsserver.Options{BindAddress: "0"}, // kein Port im Test
    })
    Expect(err).NotTo(HaveOccurred())
    Expect((&StaticSiteReconciler{
        Client:   mgr.GetClient(),
        Scheme:   mgr.GetScheme(),
        Recorder: mgr.GetEventRecorder("site-operator"),
    }).SetupWithManager(mgr)).To(Succeed())
    go func() {
        defer GinkgoRecover()
        Expect(mgr.Start(ctx)).To(Succeed())
    }()
})

var _ = AfterSuite(func() {
    By("Manager und envtest stoppen")
    cancel()
    Expect(testEnv.Stop()).To(Succeed())
})
EOF

Achtung: Ohne EnforceDefaultTimeoutsWhenUsingContexts() ignoriert Gomega den Default-Timeout, sobald du WithContext(ctx) nutzt – ein fehlschlagendes Eventually hängt dann bis zum go test-Timeout (10 min). Genau das passiert in Drill 5, wenn du es weglässt.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Test-Helfer

Kleine Helfer halten die Specs lesbar. GinkgoHelper() sorgt dafür, dass Fehler auf die aufrufende Zeile zeigen, nicht in den Helfer.

cat > internal/controller/helpers_test.go <<'EOF'
package controller

import (
    "context"
    "fmt"

    . "github.com/onsi/ginkgo/v2"
    . "github.com/onsi/gomega"
    appsv1 "k8s.io/api/apps/v1"
    corev1 "k8s.io/api/core/v1"
    "k8s.io/apimachinery/pkg/api/meta"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "sigs.k8s.io/controller-runtime/pkg/client"

    webv1alpha1 "example.com/site-operator/api/v1alpha1"
)

// newNamespace isoliert jede Spec in einem eigenen Namespace.
// envtest löscht Namespaces nie ganz (kein Namespace-Controller) – egal im Test.
func newNamespace(ctx context.Context) string {
    ns := &corev1.Namespace{ObjectMeta: metav1.ObjectMeta{GenerateName: "site-test-"}}
    Expect(k8sClient.Create(ctx, ns)).To(Succeed())
    return ns.Name
}

// newStaticSite baut eine gültige StaticSite; mutate passt sie je Test an.
func newStaticSite(ns, name string,
    mutate ...func(*webv1alpha1.StaticSite)) *webv1alpha1.StaticSite {
    site := &webv1alpha1.StaticSite{
        ObjectMeta: metav1.ObjectMeta{Name: name, Namespace: ns},
        Spec:       webv1alpha1.StaticSiteSpec{Content: "<h1>Test</h1>"},
    }
    for _, m := range mutate {
        m(site)
    }
    return site
}

// markDeploymentReady spielt den Deployment-Controller, den envtest nicht hat.
func markDeploymentReady(ctx context.Context, key client.ObjectKey, n int32) {
    GinkgoHelper()
    dep := &appsv1.Deployment{}
    Expect(k8sClient.Get(ctx, key, dep)).To(Succeed())
    patch := client.MergeFrom(dep.DeepCopy())
    dep.Status = appsv1.DeploymentStatus{
        ObservedGeneration: dep.Generation, Replicas: n,
        UpdatedReplicas: n, ReadyReplicas: n, AvailableReplicas: n,
    }
    Expect(k8sClient.Status().Patch(ctx, dep, patch)).To(Succeed())
}

// condition liefert eine Funktion für Eventually/Consistently.
func condition(ctx context.Context, key client.ObjectKey,
    typ string) func() (metav1.Condition, error) {
    return func() (metav1.Condition, error) {
        site := &webv1alpha1.StaticSite{}
        if err := k8sClient.Get(ctx, key, site); err != nil {
            return metav1.Condition{}, err
        }
        c := meta.FindStatusCondition(site.Status.Conditions, typ)
        if c == nil {
            return metav1.Condition{}, fmt.Errorf("condition %s fehlt", typ)
        }
        return *c, nil
    }
}

// haveCondition prüft Status und Reason in einem Matcher.
func haveCondition(status metav1.ConditionStatus, reason string) OmegaMatcher {
    return SatisfyAll(HaveField("Status", status), HaveField("Reason", reason))
}
EOF
go vet ./internal/controller/ && echo vet-ok

Erwartet:

vet-ok

Warum markDeploymentReady? envtest hat keinen Deployment-Controller (Tag 4) – du spielst ihn, wie mit fake_ready an Tag 5, nur in Go.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Specs für den Reconciler

Die Datei ersetzt den Kubebuilder-Test. Jede Spec erzeugt eine StaticSite und wartet auf das Ergebnis – genau das, was du an Tag 4 und 5 von Hand mit kubectl geprüft hast.

cat > internal/controller/staticsite_controller_test.go <<'EOF'
package controller

import (
    "time"

    . "github.com/onsi/ginkgo/v2"
    . "github.com/onsi/gomega"
    appsv1 "k8s.io/api/apps/v1"
    corev1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/utils/ptr"
    "sigs.k8s.io/controller-runtime/pkg/client"

    webv1alpha1 "example.com/site-operator/api/v1alpha1"
)

var _ = Describe("StaticSite Controller", func() {
    var (
        ns   string
        key  client.ObjectKey
        site *webv1alpha1.StaticSite
    )

    BeforeEach(func(ctx SpecContext) {
        ns = newNamespace(ctx)
        key = client.ObjectKey{Namespace: ns, Name: "demo"}
        site = newStaticSite(ns, "demo")
    })

    // getDeployment wartet, bis der Operator das Deployment angelegt hat.
    getDeployment := func(ctx SpecContext) *appsv1.Deployment {
        GinkgoHelper()
        dep := &appsv1.Deployment{}
        Eventually(func() error { return k8sClient.Get(ctx, key, dep) }).
            WithContext(ctx).Should(Succeed())
        return dep
    }

    It("erzeugt ConfigMap, Deployment und Service mit Owner", func(ctx SpecContext) {
        Expect(k8sClient.Create(ctx, site)).To(Succeed())

        dep := getDeployment(ctx)
        Expect(metav1.IsControlledBy(dep, site)).To(BeTrue())
        Expect(dep.Spec.Template.Annotations).
            To(HaveKey("web.lab.example/content-hash"))
        Expect(dep.Spec.Template.Spec.Containers[0].Ports[0].ContainerPort).
            To(Equal(int32(8080)))

        svc := &corev1.Service{}
        Expect(k8sClient.Get(ctx, key, svc)).To(Succeed())
        Expect(svc.Spec.Ports[0].Port).To(Equal(int32(80)))

        cm := &corev1.ConfigMap{}
        cmKey := client.ObjectKey{Namespace: ns, Name: "demo-content"}
        Expect(k8sClient.Get(ctx, cmKey, cm)).To(Succeed())
        Expect(cm.Data).To(HaveKeyWithValue("index.html", "<h1>Test</h1>"))
    })

    It("dreht manuelle Änderungen zurück", func(ctx SpecContext) {
        Expect(k8sClient.Create(ctx, site)).To(Succeed())
        dep := getDeployment(ctx)
        dep.Spec.Replicas = ptr.To[int32](5)
        Expect(k8sClient.Update(ctx, dep)).To(Succeed())

        Eventually(func(g Gomega) {
            g.Expect(k8sClient.Get(ctx, key, dep)).To(Succeed())
            g.Expect(*dep.Spec.Replicas).To(Equal(int32(1)))
        }).WithContext(ctx).Should(Succeed())
    })

    It("rollt bei neuem Inhalt mit neuem Hash aus", func(ctx SpecContext) {
        Expect(k8sClient.Create(ctx, site)).To(Succeed())
        hash := getDeployment(ctx).Spec.Template.Annotations[contentHashAnnotation]

        Expect(k8sClient.Get(ctx, key, site)).To(Succeed())
        site.Spec.Content = "<h1>Version 2</h1>"
        Expect(k8sClient.Update(ctx, site)).To(Succeed())

        Eventually(func() string {
            return getDeployment(ctx).Spec.Template.Annotations[contentHashAnnotation]
        }).WithContext(ctx).ShouldNot(Equal(hash))
    })

    It("meldet Available erst mit bereiten Pods", func(ctx SpecContext) {
        Expect(k8sClient.Create(ctx, site)).To(Succeed())
        available := condition(ctx, key, webv1alpha1.ConditionAvailable)

        Eventually(available).WithContext(ctx).Should(haveCondition(
            metav1.ConditionFalse, webv1alpha1.ReasonReplicasNotReady))
        Consistently(available).WithContext(ctx).WithTimeout(time.Second).
            Should(HaveField("Status", metav1.ConditionFalse))

        markDeploymentReady(ctx, key, 1)
        Eventually(available).WithContext(ctx).Should(haveCondition(
            metav1.ConditionTrue, webv1alpha1.ReasonAllReplicasReady))
        Expect(k8sClient.Get(ctx, key, site)).To(Succeed())
        Expect(site.Status.ObservedGeneration).To(Equal(site.Generation))
        Expect(site.Status.URL).To(Equal("http://demo." + ns + ".svc"))
    })

    It("schreibt im Ruhezustand nichts mehr (kein Hotloop)", func(ctx SpecContext) {
        Expect(k8sClient.Create(ctx, site)).To(Succeed())
        getDeployment(ctx)
        markDeploymentReady(ctx, key, 1)
        Eventually(condition(ctx, key, webv1alpha1.ConditionAvailable)).
            WithContext(ctx).Should(HaveField("Status", metav1.ConditionTrue))

        resourceVersions := func() []string {
            s, d := &webv1alpha1.StaticSite{}, &appsv1.Deployment{}
            Expect(k8sClient.Get(ctx, key, s)).To(Succeed())
            Expect(k8sClient.Get(ctx, key, d)).To(Succeed())
            return []string{s.ResourceVersion, d.ResourceVersion}
        }
        before := resourceVersions()
        Consistently(resourceVersions).WithContext(ctx).
            WithTimeout(2 * time.Second).Should(Equal(before))
    })

    It("meldet ContentMissing und erholt sich", func(ctx SpecContext) {
        site.Spec.Content = ""
        site.Spec.ContentFrom = &webv1alpha1.ContentSource{
            ConfigMapRef: &webv1alpha1.ConfigMapReference{Name: "html"},
        }
        Expect(k8sClient.Create(ctx, site)).To(Succeed())
        degraded := condition(ctx, key, webv1alpha1.ConditionDegraded)
        Eventually(degraded).WithContext(ctx).Should(haveCondition(
            metav1.ConditionTrue, webv1alpha1.ReasonContentMissing))

        Expect(k8sClient.Create(ctx, &corev1.ConfigMap{
            ObjectMeta: metav1.ObjectMeta{Name: "html", Namespace: ns},
            Data:       map[string]string{"index.html": "<h1>CM</h1>"},
        })).To(Succeed())
        // Bis Tag 10 beobachtet der Operator fremde ConfigMaps nicht:
        // eine Annotation weckt ihn, statt 30 s auf RequeueAfter zu warten.
        Expect(k8sClient.Get(ctx, key, site)).To(Succeed())
        site.Annotations = map[string]string{"test/poke": "1"}
        Expect(k8sClient.Update(ctx, site)).To(Succeed())

        Eventually(degraded).WithContext(ctx).Should(haveCondition(
            metav1.ConditionFalse, webv1alpha1.ReasonAsExpected))
    })
})
EOF
go test ./internal/controller/ -count=1 -v -ginkgo.v -ginkgo.no-color 2>&1 \
  | grep -E '^(StaticSite Controller|Ran [0-9]|SUCCESS)'

Erwartet (Reihenfolge variiert):

StaticSite Controller erzeugt ConfigMap, Deployment und Service mit Owner
StaticSite Controller dreht manuelle Änderungen zurück
StaticSite Controller rollt bei neuem Inhalt mit neuem Hash aus
StaticSite Controller meldet Available erst mit bereiten Pods
StaticSite Controller schreibt im Ruhezustand nichts mehr (kein Hotloop)
StaticSite Controller meldet ContentMissing und erholt sich
Ran 9 of 9 Specs in 9.144 seconds
SUCCESS! -- 9 Passed | 0 Failed | 0 Pending | 0 Skipped

Drei Muster:

Werkzeug Frage Beispiel
Eventually Wird es irgendwann wahr? Deployment existiert
Consistently Bleibt es eine Weile wahr? kein Hotloop, noch nicht Available
func(g Gomega) mehrere Prüfungen pro Versuch Get + Replicas vergleichen

Fortschritt speichern? Kostenlos registrieren

Drill 5: Ein Test muss rot werden können

Ein Test, der nie fehlschlägt, beweist nichts. Entferne Owns(&appsv1.Deployment{}) – dann merkt der Operator manuelle Änderungen am Deployment nicht mehr:

F=internal/controller/staticsite_controller.go
cp $F lab/controller.keep
sed -i.bak '/Owns(&appsv1.Deployment{})/d' $F && rm $F.bak
go test ./internal/controller/ -count=1 -ginkgo.no-color -ginkgo.focus="zurück" 2>&1 \
  | grep -E 'Timed out|<int32>|^\s+to equal|Ran [0-9]|FAIL!'
cp lab/controller.keep $F && rm lab/controller.keep

Erwartet:

  [FAILED] Timed out after 10.000s.
      <int32>: 5
  to equal
      <int32>: 1
Ran 1 of 9 Specs in 15.947 seconds
FAIL! -- 0 Passed | 1 Failed | 0 Pending | 8 Skipped

-ginkgo.focus wählt Specs per Regex auf den Namen. Nach dem Zurückkopieren ist alles wieder grün.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Tabellen – mit und ohne API-Server

DescribeTable ist Ginkgos Tabellentest. Hier prüft der echte API-Server die CRD-Validierung aus Tag 3:

cat > internal/controller/validation_test.go <<'EOF'
package controller

import (
    "strings"

    . "github.com/onsi/ginkgo/v2"
    . "github.com/onsi/gomega"
    apierrors "k8s.io/apimachinery/pkg/api/errors"

    webv1alpha1 "example.com/site-operator/api/v1alpha1"
)

type siteMutator = func(*webv1alpha1.StaticSite)

func replicas(n int32) siteMutator {
    return func(s *webv1alpha1.StaticSite) { s.Spec.Replicas = n }
}

var _ = DescribeTable("CRD-Validierung",
    func(ctx SpecContext, mutate siteMutator, valid bool) {
        site := newStaticSite(newNamespace(ctx), "v", mutate)
        err := k8sClient.Create(ctx, site)
        if valid {
            Expect(err).NotTo(HaveOccurred())
            return
        }
        Expect(apierrors.IsInvalid(err)).To(BeTrue(), "err = %v", err)
    },
    Entry("minimal", func(*webv1alpha1.StaticSite) {}, true),
    Entry("10 Replikas", replicas(10), true),
    Entry("11 Replikas", replicas(11), false),
    // omitempty: 0 wird gar nicht gesendet, der Server setzt den Default 1.
    Entry("0 Replikas = Default", replicas(0), true),
    Entry("Inhalt über 64 KiB", func(s *webv1alpha1.StaticSite) {
        s.Spec.Content = strings.Repeat("x", 64*1024+1)
    }, false),
)
EOF

Die Mutate-Funktionen aus Tag 4 brauchen gar keinen Cluster – eine klassische Go-Tabelle reicht und prüft nebenbei Idempotenz:

cat > internal/controller/resources_test.go <<'EOF'
package controller

import (
    "testing"

    appsv1 "k8s.io/api/apps/v1"
    "k8s.io/apimachinery/pkg/api/equality"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

    webv1alpha1 "example.com/site-operator/api/v1alpha1"
)

// Reiner Unit-Test: kein API-Server, läuft in Millisekunden.
func TestMutateDeployment(t *testing.T) {
    tests := []struct {
        name, path, wantMount string
    }{
        {"Wurzel", "/", "/usr/share/nginx/html"},
        {"Unterpfad", "/docs", "/usr/share/nginx/html/docs"},
        {"ohne führenden Slash", "blog/", "/usr/share/nginx/html/blog"},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            site := &webv1alpha1.StaticSite{
                ObjectMeta: metav1.ObjectMeta{Name: "demo"},
                Spec: webv1alpha1.StaticSiteSpec{
                    Path: tt.path, Replicas: 2, Image: "nginx:lab",
                },
            }
            dep := &appsv1.Deployment{}
            mutateDeployment(dep, site, "abc")

            mount := dep.Spec.Template.Spec.Containers[0].VolumeMounts[0]
            if mount.MountPath != tt.wantMount {
                t.Errorf("MountPath = %q, want %q", mount.MountPath, tt.wantMount)
            }
            before := dep.DeepCopy()
            mutateDeployment(dep, site, "abc") // zweiter Lauf darf nichts ändern
            if !equality.Semantic.DeepEqual(before, dep) {
                t.Error("mutateDeployment ist nicht idempotent")
            }
        })
    }
}
EOF
go test ./internal/controller/ -count=1 -run TestMutateDeployment -v 2>&1 \
  | grep -E '^\s*--- |^ok'
go test ./internal/controller/ -count=1 -v -ginkgo.v -ginkgo.no-color 2>&1 \
  | grep -E '^(CRD|Ran [0-9]|SUCCESS)'

Erwartet (Laufzeiten variieren):

--- PASS: TestMutateDeployment (0.00s)
    --- PASS: TestMutateDeployment/Wurzel (0.00s)
    --- PASS: TestMutateDeployment/Unterpfad (0.00s)
    --- PASS: TestMutateDeployment/ohne_führenden_Slash (0.00s)
ok      example.com/site-operator/internal/controller   0.372s
CRD-Validierung minimal
CRD-Validierung 10 Replikas
CRD-Validierung 11 Replikas
CRD-Validierung 0 Replikas = Default
CRD-Validierung Inhalt über 64 KiB
Ran 14 of 14 Specs in 9.258 seconds
SUCCESS! -- 14 Passed | 0 Failed | 0 Pending | 0 Skipped

-run TestMutateDeployment startet kein envtest – TestControllers wird gar nicht ausgeführt. Der Eintrag „0 Replikas” zeigt eine Falle aus Tag 3: Wegen omitempty sendet Go die 0 nie, der Server setzt den Default 1. Willst du 0 erlauben oder ablehnen, braucht das Feld einen Pointer.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Fehlerpfade mit dem fake client

Der fake client aus controller-runtime ist ein In-Memory-Store ohne Defaults, Validierung und Watches. Für Fehlerpfade ist das ideal: schnell, deterministisch, ohne Manager. events.NewFakeRecorder sammelt Events in einem Channel.

cat > internal/controller/reconcile_fake_test.go <<'EOF'
package controller

import (
    "context"
    "strings"
    "testing"
    "time"

    "k8s.io/apimachinery/pkg/api/meta"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/apimachinery/pkg/runtime"
    clientgoscheme "k8s.io/client-go/kubernetes/scheme"
    "k8s.io/client-go/tools/events"
    ctrl "sigs.k8s.io/controller-runtime"
    "sigs.k8s.io/controller-runtime/pkg/client"
    "sigs.k8s.io/controller-runtime/pkg/client/fake"

    webv1alpha1 "example.com/site-operator/api/v1alpha1"
)

// Der fake client kennt weder Defaults noch Validierung – ideal für Fehlerpfade.
func TestReconcileContentMissing(t *testing.T) {
    scheme := runtime.NewScheme()
    _ = clientgoscheme.AddToScheme(scheme)
    _ = webv1alpha1.AddToScheme(scheme)

    site := &webv1alpha1.StaticSite{
        ObjectMeta: metav1.ObjectMeta{Name: "demo", Namespace: "default"},
        Spec: webv1alpha1.StaticSiteSpec{Replicas: 1,
            ContentFrom: &webv1alpha1.ContentSource{
                ConfigMapRef: &webv1alpha1.ConfigMapReference{Name: "fehlt"},
            }},
    }
    c := fake.NewClientBuilder().WithScheme(scheme).
        WithObjects(site).WithStatusSubresource(site).Build()
    rec := events.NewFakeRecorder(10)
    r := &StaticSiteReconciler{Client: c, Scheme: scheme, Recorder: rec}

    key := client.ObjectKeyFromObject(site)
    res, err := r.Reconcile(context.Background(), ctrl.Request{NamespacedName: key})
    if err != nil || res.RequeueAfter != 30*time.Second {
        t.Fatalf("Reconcile = %+v, %v; want RequeueAfter 30s, nil", res, err)
    }

    got := &webv1alpha1.StaticSite{}
    if err := c.Get(context.Background(), key, got); err != nil {
        t.Fatal(err)
    }
    cond := meta.FindStatusCondition(got.Status.Conditions,
        webv1alpha1.ConditionDegraded)
    if cond == nil || cond.Reason != webv1alpha1.ReasonContentMissing {
        t.Fatalf("Degraded = %+v, want Reason ContentMissing", cond)
    }

    close(rec.Events)
    var warnings []string
    for e := range rec.Events {
        if strings.HasPrefix(e, "Warning ContentMissing") {
            warnings = append(warnings, e)
        }
    }
    if len(warnings) != 1 {
        t.Errorf("Warning-Events = %q, want genau eins", warnings)
    }
}
EOF
go test ./internal/controller/ -count=1 -run TestReconcileContentMissing -v 2>&1 \
  | grep -E '^(--- |ok)'

Erwartet:

--- PASS: TestReconcileContentMissing (0.04s)
ok      example.com/site-operator/internal/controller   0.419s

WithStatusSubresource(site) ist Pflicht, sonst schreibt der fake client Status().Patch nicht wie ein echter API-Server. Faustregel: fake client für Logik und Fehlerpfade, envtest für alles, was Watches, Defaults oder Validierung braucht.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Coverage, Race-Detector und CI

Jetzt alles zusammen – so, wie es auch die Pipeline ausführt:

go test ./internal/controller/ -count=1 -race -coverprofile=cover.out \
  -ginkgo.no-color -ginkgo.junit-report=junit.xml
go tool cover -func=cover.out | grep -E 'Reconcile|updateStatus|total'
grep -o '<testsuites [^>]*>' internal/controller/junit.xml

Erwartet (gekürzt):

ok      example.com/site-operator/internal/controller   11.839s coverage: 93.8% ...
.../internal/controller/staticsite_controller.go:44:    Reconcile   90.0%
.../internal/controller/status.go:20:           updateStatus    100.0%
total:                          (statements)    93.8%
<testsuites tests="16" disabled="0" errors="0" failures="0" time="9.902920667">

-race findet Datenrennen zwischen Manager-Goroutinen und Testcode; junit.xml (liegt im Paketverzeichnis, 14 Specs + BeforeSuite/AfterSuite) lesen GitLab, Jenkins und GitHub als Testbericht. go tool cover -html=cover.out zeigt, welche Zeilen kein Test erreicht.

Kubebuilder hat die CI schon angelegt: .github/workflows/test.yml ruft make test. Das Target lädt die envtest-Binaries per setup-envtest nach bin/k8s/ und testet alle Pakete außer test/e2e:

grep -A1 '^test:' Makefile
make test 2>&1 | tail -4

Erwartet (gekürzt):

test: manifests generate fmt vet setup-envtest ## Run tests.
    KUBEBUILDER_ASSETS="$(shell "$(ENVTEST)" use $(ENVTEST_K8S_VERSION) ...
    example.com/site-operator/api/v1alpha1      coverage: 0.0% of statements
    example.com/site-operator/cmd       coverage: 0.0% of statements
ok      example.com/site-operator/internal/controller   10.452s coverage: 93.0% ...
    example.com/site-operator/test/utils        coverage: 0.0% of statements

Tipp: make test lädt beim ersten Mal rund 100 MB nach bin/k8s/. Lokal reicht go test ./internal/... mit KUBEBUILDER_ASSETS aus env.sh; in CI cachst du bin/ zwischen Läufen.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

cat > lab/check.sh <<'EOF'
ok()  { echo "✔ $1"; }
nok() { echo "✘ $1"; }
P=./internal/controller/
env -u KUBEBUILDER_ASSETS go test $P -count=1 \
  -run 'TestMutateDeployment|TestReconcileContentMissing' >/dev/null 2>&1 \
  && ok "Unit-Tests ohne envtest" || nok "Unit-Tests"
out=$(go test $P -count=1 -v -ginkgo.no-color -coverprofile=cover.out 2>&1)
echo "$out" | grep -q '^SUCCESS!' && ok "envtest-Suite grün" || nok "Suite rot"
n=$(echo "$out" | sed -nE 's/^Ran ([0-9]+) of.*/\1/p')
[ "${n:-0}" -ge 14 ] && ok "$n Specs" || nok "zu wenige Specs (${n:-0})"
cov=$(go tool cover -func=cover.out | awk '/^total:/ {print int($3)}')
[ "${cov:-0}" -ge 80 ] && ok "Coverage ${cov}%" || nok "Coverage ${cov:-0}%"
grep -l 'time.Sleep' internal/controller/*_test.go >/dev/null \
  && nok "time.Sleep in Tests" || ok "kein time.Sleep – nur Eventually"
EOF
bash lab/check.sh

Erwartet:

✔ Unit-Tests ohne envtest
✔ envtest-Suite grün
✔ 14 Specs
✔ Coverage 92%
✔ kein time.Sleep – nur Eventually

Challenge

Schreibe eine envtest-Spec, die beweist, dass bei fehlender ConfigMap ein Warning-Event mit Reason ContentMissing im Namespace landet.

Hinweis: Der Recorder schreibt events.k8s.io/v1-Events; k8sClient.List mit eventsv1.EventList und client.InNamespace(ns) findet sie, ContainElement + HaveField prüft sie.

Lösung

cat > internal/controller/events_test.go <<'EOF'
package controller

import (
    . "github.com/onsi/ginkgo/v2"
    . "github.com/onsi/gomega"
    eventsv1 "k8s.io/api/events/v1"
    "sigs.k8s.io/controller-runtime/pkg/client"

    webv1alpha1 "example.com/site-operator/api/v1alpha1"
)

var _ = It("erzeugt ein Warning-Event bei fehlendem Inhalt", func(ctx SpecContext) {
    ns := newNamespace(ctx)
    site := newStaticSite(ns, "ohne-cm", func(s *webv1alpha1.StaticSite) {
        s.Spec.Content = ""
        s.Spec.ContentFrom = &webv1alpha1.ContentSource{
            ConfigMapRef: &webv1alpha1.ConfigMapReference{Name: "fehlt"},
        }
    })
    Expect(k8sClient.Create(ctx, site)).To(Succeed())

    Eventually(func(g Gomega) []eventsv1.Event {
        var list eventsv1.EventList
        g.Expect(k8sClient.List(ctx, &list, client.InNamespace(ns))).To(Succeed())
        return list.Items
    }).WithContext(ctx).Should(ContainElement(SatisfyAll(
        HaveField("Type", "Warning"),
        HaveField("Reason", webv1alpha1.ReasonContentMissing),
        HaveField("Regarding.Name", "ohne-cm"),
    )))
})
EOF
go test ./internal/controller/ -count=1 -v -ginkgo.v -ginkgo.no-color \
  -ginkgo.focus="Warning-Event" 2>&1 | grep -E '^(erzeugt|Ran [0-9]|SUCCESS)'

Erwartet:

erzeugt ein Warning-Event bei fehlendem Inhalt
Ran 1 of 15 Specs in 5.341 seconds
SUCCESS! -- 1 Passed | 0 Failed | 0 Pending | 14 Skipped

HaveField("Regarding.Name", …) greift in verschachtelte Felder. Der Code-Stand in code/tag06-site-operator enthält die Challenge nicht.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • envtest-Suiten parallelisieren: ginkgo -p startet pro Prozess eine eigene Control Plane – Namespaces pro Spec (wie hier) sind die Voraussetzung.
  • Pipelines pinnen die envtest-Version (ENVTEST_K8S_VERSION) auf die kleinste unterstützte Kubernetes-Version des Kunden und testen zusätzlich gegen die neueste.
  • envtest ersetzt keinen E2E-Test: Images, RBAC im Cluster, Webhooks mit echten Zertifikaten und Pod-Verhalten prüft erst ein kind-Lauf (Tag 12).
  • Flaky Tests sofort reparieren, nie mit FlakeAttempts oder längeren Timeouts zudecken – meist steckt ein echtes Race oder ein Hotloop dahinter.
  • Testberichte (junit.xml) und Coverage als Pipeline-Artefakt ablegen; Coverage-Schwellen pro Paket statt global, sonst verwässern cmd/ und test/utils.