C++ Academy · Lezione

Mocking con GMock

Simulare le dipendenze

Mocking con GMock è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.

Perché usare i mock?

GMock crea oggetti fittizi che registrano le chiamate e restituiscono risultati programmati. Il mocking isola l'unità sottoposta a test da dipendenze lente o imprevedibili, come database o reti.

Iniziare da un'interfaccia

Le dipendenze che si desidera sottoporre a mocking sono solitamente classi base astratte con metodi virtuali.

#include <string>

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

Definire una classe mock

Utilizzi MOCK_METHOD per generare un mock per ogni metodo virtuale, specificando tipo restituito, nome, argomenti e qualificatori.

#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));
};

Impostare le aspettative

EXPECT_CALL specifica come deve essere chiamato un metodo mock e cosa deve restituire. WillOnce(Return(...)) programma il risultato.

#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");
}

Matcher degli argomenti

Le aspettative possono confrontare gli argomenti in modo flessibile con matcher come _ (qualsiasi valore), Gt(5) o 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");
}

Cardinalità

Specifichi quante volte deve essere prevista una chiamata con Times.

Times(1) esattamente una volta
Times(AtLeast(2))
Times(0) non deve mai essere chiamata

#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);
}

Azioni di ritorno

Le azioni determinano il comportamento.

Return(value)
ReturnRef(ref)
Throw(exception)
Invoke(callable) per eseguire codice personalizzato

Iniettare il mock

L'unità sottoposta a test deve accettare la dipendenza tramite un puntatore o un riferimento all'interfaccia. Questa è l'iniezione delle dipendenze ed è ciò che rende possibile il mocking.

#include <string>

class Database;

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

Verificare le interazioni

GMock verifica tutte le aspettative di EXPECT_CALL quando il mock viene distrutto. Le aspettative non soddisfatte, dovute a un numero errato di chiamate o a chiamate mancanti, fanno fallire automaticamente il test.

Mock Nice, Strict e Naggy

Controlli come vengono gestite le chiamate impreviste.

NiceMock: ignora le chiamate non rilevanti
StrictMock: qualsiasi chiamata imprevista fa fallire il test
Predefinito (naggy): mostra un avviso per le chiamate non rilevanti

Eseguire il mocking solo di ciò che si possiede

È preferibile eseguire il mocking delle proprie interfacce, non delle classi concrete di terze parti. Introduca sottili interfacce wrapper attorno alle librerie esterne, così i test rimangono stabili.

Verifica rapida

Ricordi quando GMock verifica le aspettative.

Riepilogo

Ha imparato a usare GMock.

Eseguire il mocking delle interfacce virtuali con MOCK_METHOD
EXPECT_CALL e le azioni programmano il comportamento
I matcher e Times controllano gli argomenti e la cardinalità
Iniettare i mock; le aspettative vengono verificate alla distruzione

Domande Frequenti

La lezione «Mocking con GMock» è gratuita?

Sì — il testo completo di «Mocking con GMock» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.

Cosa imparerò in «Mocking con GMock»?

Simulare le dipendenze Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C++ Academy?

Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Mocking con GMock»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C++ Academy?

Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C++ Academy