C++ Academy · Lección

Mocking con GMock

Simule dependencias

Mocking con GMock es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.

¿Por qué usar mocks?

GMock crea objetos simulados que registran llamadas y devuelven resultados programados. El uso de mocks aísla la unidad bajo prueba de dependencias lentas o impredecibles, como bases de datos o redes.

Comenzar con una interfaz

Las dependencias aptas para usar mocks suelen ser clases base abstractas con métodos virtuales.

#include <string>

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

Definir una clase mock

Utilice MOCK_METHOD para generar un mock para cada método virtual e indique el tipo de retorno, el nombre, los argumentos y los calificadores.

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

Establecer expectativas

EXPECT_CALL indica cómo debe llamarse un método del mock y qué devuelve. WillOnce(Return(...)) configura el resultado.

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

Matchers de argumentos

Las expectativas pueden hacer coincidir los argumentos de forma flexible mediante matchers como _ (cualquiera), 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");
}

Cardinalidad

Especifique cuántas veces se espera una llamada con Times.

Times(1) exactamente una vez
Times(AtLeast(2))
Times(0) no debe llamarse nunca

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

Acciones de retorno

Las acciones determinan el comportamiento.

Return(value)
ReturnRef(ref)
Throw(exception)
Invoke(callable) para ejecutar código personalizado

Inyección del mock

La unidad bajo prueba debe aceptar la dependencia mediante un puntero o una referencia a la interfaz. Esto es la inyección de dependencias y es lo que hace posible usar mocks.

#include <string>

class Database;

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

Verificación de interacciones

GMock verifica todas las expectativas de EXPECT_CALL cuando se destruye el mock. Las expectativas no satisfechas (por un número incorrecto de llamadas o por llamadas ausentes) hacen que la prueba falle automáticamente.

Mocks Nice, Strict y Naggy

Controle cómo se tratan las llamadas inesperadas.

NiceMock: ignora las llamadas no relevantes
StrictMock: cualquier llamada inesperada provoca un fallo
Predeterminado (naggy): muestra advertencias sobre las llamadas no relevantes

Use mocks solo para lo que controla

Es preferible crear mocks de sus propias interfaces, no de clases concretas de terceros. Introduzca interfaces envoltorio delgadas alrededor de las bibliotecas externas para que las pruebas se mantengan estables.

Comprobación rápida

Recuerde cuándo comprueba GMock las expectativas.

Repaso

Ha aprendido a usar GMock.

Crear mocks de interfaces virtuales con MOCK_METHOD
EXPECT_CALL y las acciones programan el comportamiento
Los matchers y Times controlan los argumentos y la cardinalidad
Inyectar mocks; las expectativas se verifican al destruirlos

Preguntas frecuentes

¿La lección «Mocking con GMock» es gratis?

Sí — el texto completo de «Mocking con GMock» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Mocking con GMock»?

Simule dependencias Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C++ Academy?

No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Mocking con GMock»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C++ Academy?

Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C++ Academy