Go Academy · Lektion

Test-Doubles: Mocks und Stubs

Interfaces für Testbarkeit und Dependency Injection

Lektion 3 von 413 Schritte

Test-Doubles: Mocks und Stubs ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Überblick über Testdoubles

Ein Testdouble ersetzt in Tests eine echte Abhängigkeit. Typen: stub (liefert vorgefertigte Antworten), mock (überprüft Interaktionen), spy (zeichnet Aufrufe auf), fake (funktionierende Implementierung im Speicher).

Interfaces ermöglichen Testdoubles

Entwerfen Sie Funktionen so, dass sie Interfaces statt konkreter Typen akzeptieren. In der Produktion übergeben Sie die echte Implementierung, in Tests ein Testdouble.

type UserStore interface {
    FindByID(id int) (*User, error)
}

func GetUser(store UserStore, id int) (*User, error) {
    return store.FindByID(id)
}

Manueller Stub

Ein Stub ist eine einfache Struct, die ein Interface implementiert und vorkonfigurierte Werte zurückgibt:

type stubStore struct{ user *User; err error }
func (s *stubStore) FindByID(_ int) (*User, error) { return s.user, s.err }

// In test:
store := &stubStore{user: &User{Name: "Alice"}}
result, _ := GetUser(store, 1)

Manueller Mock

Ein Mock zeichnet Aufrufe auf und überprüft sie:

type mockStore struct {
    called bool
    gotID  int
    user   *User
}
func (m *mockStore) FindByID(id int) (*User, error) {
    m.called = true; m.gotID = id
    return m.user, nil
}
// Assert: if !mock.called { t.Error(...) }

testify/mock

Das Paket testify/mock generiert oder schreibt Mock-Objekte mit Aufruferwartungen und konfigurierbaren Rückgabewerten:

type MockStore struct { mock.Mock }
func (m *MockStore) FindByID(id int) (*User, error) {
    args := m.Called(id)
    return args.Get(0).(*User), args.Error(1)
}
// In test:
m := new(MockStore)
m.On("FindByID", 1).Return(&User{}, nil)
m.AssertExpectations(t)

gomock

go.uber.org/mock/gomock (früher golang/mock) generiert Mocks aus Interfaces. Verwenden Sie die CLI mockgen zum Generieren und EXPECT() zum Festlegen von Erwartungen.

Fake

Ein Fake ist eine funktionierende Implementierung im Speicher. Beispielsweise kann ein User-Store im Speicher Benutzer in einer Map speichern. Fakes sind aufwendiger zu schreiben, aber realistischer und weniger fragil als Mocks.

type fakeStore struct{ users map[int]*User }
func (f *fakeStore) FindByID(id int) (*User, error) {
    u, ok := f.users[id]
    if !ok { return nil, ErrNotFound }
    return u, nil
}

httptest für HTTP-Clients

net/http/httptest stellt einen HTTP-Testserver und einen Recorder innerhalb des Prozesses bereit – das Standard-Fake für HTTP-basierte Abhängigkeiten.

ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    json.NewEncoder(w).Encode(User{Name: "Alice"})
}))
defer ts.Close()

Wann welches Testdouble verwenden

Stub: einfache feste Antwort. Mock: Anzahl und Argumente von Aufrufen überprüfen. Fake: komplexes Verhalten. Vermeiden Sie übermäßiges Mocking – Fakes und echte Komponenten in Integrationstests sind zuverlässiger.

Fragile Tests vermeiden

Mocks, die eine exakte Aufrufreihenfolge oder Argumentwerte überprüfen, werden fragil, wenn sich die Implementierung weiterentwickelt. Bevorzugen Sie nach Möglichkeit Stubs mit Ausgabeprüfungen oder Fakes.

Interfaces ableiten

Leiten Sie Interfaces ab, nachdem Sie die von den Aufrufern verwendete Oberfläche des konkreten Typs ermittelt haben (ISP). Go unterstützt die implizite Erfüllung von Interfaces – am konkreten Typ sind keine Änderungen erforderlich.

Kurzer Test

Was ist der wichtigste Unterschied zwischen einem Stub und einem Mock?

Zusammenfassung: Testdoubles

Wichtige Punkte:

  • Entwerfen Sie anhand von Interfaces, um Testdoubles zu ermöglichen
  • Stub: liefert vorgefertigte Daten; Mock: überprüft Interaktionen
  • httptest für HTTP; Fakes im Speicher für Speicherkomponenten
  • Vermeiden Sie übermäßiges Mocking – bevorzugen Sie bei komplexem Verhalten Fakes
Kostenlos starten

Lerne Go mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
51
Lektionen
203

Häufig gestellte Fragen

Ist die Lektion „Test-Doubles: Mocks und Stubs“ kostenlos?

Ja — der vollständige Text von „Test-Doubles: Mocks und Stubs“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Test-Doubles: Mocks und Stubs“?

Interfaces für Testbarkeit und Dependency Injection Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Test-Doubles: Mocks und Stubs“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Unit-Tests mit testing schreiben
  2. Tabellengesteuerte Tests
  3. Test-Doubles: Mocks und Stubs
  4. Testabdeckung und testify
← Zurück zu Go Academy