[Dúvida] Diferença entre mock e stub

Oi Vitor! Tudo bem?

É mais normal do que você imagina essa confusão, pois os conceitos de mock e stub podem parecer semelhantes, mas há algumas diferenças sutis e importantes entre eles. Então, vou tentar esclarecer com base nos exemplos que você mencionou.

Mock

Um mock é um objeto simulado que imita o comportamento de um objeto real. Ele pode ser configurado para retornar valores específicos quando certos métodos são chamados, e é usado para substituir dependências externas em um teste. O objetivo principal de um mock é isolar o código em teste, garantindo que ele não dependa do comportamento de objetos externos.

Stub

Um stub é um tipo específico de mock que substitui um método ou função específica por uma implementação simulada. Ele é usado para controlar o comportamento de um objeto durante um teste, fornecendo resultados predefinidos para determinadas chamadas de método. Em resumo, stubs servem para simular o comportamento de objetos complexos e garantir que o código em teste seja testado de forma isolada.

Exemplos Práticos

Mock No exemplo abaixo, usamos jest.fn() para criar um mock da função addUser:

// userService.ts
import { User } from './user';

export interface UserService {
  addUser(user: User): Promise<User>;
}

// userController.ts
import { UserService } from './userService';
import { User } from './user';

export class UserController {
  constructor(private readonly userService: UserService) {}

  async createUser(user: User): Promise<User> {
    return await this.userService.addUser(user);
  }
}

// userController.spec.ts
import { UserController } from './userController';
import { UserService } from './userService';
import { User } from './user';

describe('UserController', () => {
  it('deve chamar addUser com o usuário correto', async () => {
    const userService: UserService = {
      addUser: jest.fn().mockResolvedValue({
        id: '1',
        name: 'John Doe',
        email: 'john@example.com',
      }),
    };

    const userController = new UserController(userService);

    const user: User = {
      id: '1',
      name: 'John Doe',
      email: 'john@example.com',
    };

    await userController.createUser(user);

    expect(userService.addUser).toHaveBeenCalledWith(user);
  });
});

Stub No exemplo abaixo, usamos jest.fn() para criar um stub da função sendNotification:

// notificationService.ts
export class NotificationService {
  sendNotification(message: string): void {
    console.log(`Notification sent: ${message}`);
  }
}

// notificationController.ts
import { NotificationService } from './notificationService';

export class NotificationController {
  constructor(private readonly notificationService: NotificationService) {}

  notify(message: string): void {
    this.notificationService.sendNotification(message);
  }
}

// notificationController.spec.ts
import { NotificationController } from './notificationController';
import { NotificationService } from './notificationService';

describe('NotificationController', () => {
  it('deve chamar sendNotification com a mensagem correta', () => {
    const notificationService = new NotificationService();
    const notificationController = new NotificationController(notificationService);

    const sendNotificationSpy = jest.spyOn(notificationService, 'sendNotification');

    const message = 'Hello, World!';
    notificationController.notify(message);

    expect(sendNotificationSpy).toHaveBeenCalledWith(message);
    expect(sendNotificationSpy).toHaveBeenCalledTimes(1);
  });
});

• Mock: Usado para substituir objetos reais por versões simuladas, controlando seu comportamento e retornando valores predefinidos.
• Stub: Um tipo específico de mock que substitui métodos específicos de um objeto por implementações simuladas, fornecendo resultados predefinidos.

Espero ter ajudado e bons estudos!