C++ Academy · Lekcja

Mockowanie za pomocą GMock

Twórz mocki zależności

Mockowanie za pomocą GMock to bezpłatna lekcja C++ Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C++ Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C++ Academy zawiera 4 lekcji w sumie.

Po co używać mocków?

GMock tworzy obiekty zastępcze, które rejestrują wywołania i zwracają zaprogramowane wyniki. Mockowanie izoluje testowany moduł od powolnych lub nieprzewidywalnych zależności, takich jak bazy danych czy sieci.

Rozpoczęcie od interfejsu

Zależności, dla których można używać mocków, są zwykle abstrakcyjnymi klasami bazowymi z metodami wirtualnymi.

#include <string>

class Database {
public:
    virtual ~Database() = default;
    virtual std::string get(int id) = 0;
    virtual bool save(const std::string& v) = 0;
};

Definiowanie klasy mock

Za pomocą MOCK_METHOD można wygenerować mock dla każdej metody wirtualnej, określając typ zwracany, nazwę, argumenty i kwalifikatory.

#include <gmock/gmock.h>
#include <string>

class Database {
public:
    virtual ~Database() = default;
    virtual std::string get(int id) = 0;
};

class MockDatabase : public Database {
public:
    MOCK_METHOD(std::string, get, (int id), (override));
};

Ustawianie oczekiwań

EXPECT_CALL określa, jak powinna zostać wywołana metoda mocka i co powinna zwrócić. WillOnce(Return(...)) programuje wynik.

#include <gmock/gmock.h>
using ::testing::Return;

TEST(DbTest, ReturnsValue) {
    MockDatabase db;
    EXPECT_CALL(db, get(1)).WillOnce(Return("alice"));
    EXPECT_EQ(db.get(1), "alice");
}

Dopasowywanie argumentów

Oczekiwania mogą luźno dopasowywać argumenty za pomocą matcherów, takich jak _ (dowolny), Gt(5) lub HasSubstr("x").

#include <gmock/gmock.h>
using ::testing::_;
using ::testing::Return;

TEST(DbTest, AnyId) {
    MockDatabase db;
    EXPECT_CALL(db, get(_)).WillRepeatedly(Return("x"));
    EXPECT_EQ(db.get(99), "x");
}

Liczność

Za pomocą Times można określić, ile razy powinno nastąpić wywołanie.

Times(1) dokładnie raz
Times(AtLeast(2))
Times(0) wywołanie nie może nastąpić ani razu

#include <gmock/gmock.h>
using ::testing::AtLeast;
using ::testing::Return;

TEST(DbTest, CalledTwice) {
    MockDatabase db;
    EXPECT_CALL(db, get(1)).Times(AtLeast(2)).WillRepeatedly(Return("v"));
    db.get(1);
    db.get(1);
}

Akcje zwracania

Akcje określają zachowanie.

Return(value)
ReturnRef(ref)
Throw(exception)
Invoke(callable) do uruchamiania własnego kodu

Wstrzykiwanie mocka

Testowany moduł musi przyjmować zależność za pośrednictwem wskaźnika lub referencji do interfejsu. Jest to wstrzykiwanie zależności i właśnie ono umożliwia mockowanie.

#include <string>

class Database;

class UserService {
    Database& db;
public:
    UserService(Database& d) : db(d) {}
    std::string name(int id);
};

Weryfikowanie interakcji

GMock weryfikuje wszystkie oczekiwania EXPECT_CALL podczas niszczenia mocka. Niespełnione oczekiwania (nieprawidłowa liczba wywołań lub ich brak) automatycznie powodują niepowodzenie testu.

Mocki Nice, Strict i Naggy

Określają Państwo, jak traktować nieoczekiwane wywołania.

NiceMock: ignoruje nieistotne wywołania
StrictMock: każde nieoczekiwane wywołanie powoduje niepowodzenie
Domyślny (naggy): ostrzega o nieistotnych wywołaniach

Mockuj tylko własny kod

Warto przede wszystkim mockować własne interfejsy, a nie konkretne klasy dostarczane przez biblioteki innych firm. Wokół zewnętrznych bibliotek należy wprowadzać cienkie interfejsy opakowujące, aby testy pozostały stabilne.

Szybkie sprawdzenie

Przypomnij sobie, kiedy GMock sprawdza oczekiwania.

Podsumowanie

Poznali Państwo GMock.

Mockowanie wirtualnych interfejsów za pomocą MOCK_METHOD
EXPECT_CALL i akcje programują zachowanie
Matchery i Times kontrolują argumenty oraz liczność
Mocki należy wstrzykiwać; oczekiwania są weryfikowane podczas niszczenia mocka

Często zadawane pytania

Czy lekcja „Mockowanie za pomocą GMock” jest bezpłatna?

Tak — pełny tekst „Mockowanie za pomocą GMock” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C++ Academy, przejdź na CoddyKit PRO. Kurs C++ Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Mockowanie za pomocą GMock”?

Twórz mocki zależności Ćwiczysz C++ Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C++ Academy?

Nie wymagamy żadnego doświadczenia. C++ Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Mockowanie za pomocą GMock”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C++ Academy?

Tak. Każda lekcja C++ Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C++ Academy