mkdir api-test-demo
cd api-test-demo
npm init -y
npm install express jest supertest cross-env
npm install --save-dev @types/express @types/jest @types/supertest # Para quem usa TypeScript, essencial. Para JS puro, opcional.

📋 Copiar

api-test-demo/
├── src/
│   ├── models/
│   │   └── UserModel.js
│   ├── services/
│   │   └── UserService.js
│   ├── controllers/
│   │   └── UserController.js
│   ├── routes/
│   │   └── UserRoutes.js
│   └── app.js
├── tests/
│   ├── unit/
│   │   └── userService.test.js
│   ├── integration/
│   │   └── userController.test.js
│   └── e2e/
│       └── userFlow.test.js
├── .env.test
├── .env.development
├── jest.config.js
└── package.json

📋 Copiar

NODE_ENV=test
PORT=3001
DB_CONNECTION_STRING=mongodb://localhost:27017/test_db_api_test_demo # Banco de dados exclusivo para testes
LOG_LEVEL=warn

📋 Copiar

NODE_ENV=development
PORT=3000
DB_CONNECTION_STRING=mongodb://localhost:27017/dev_db_api_test_demo # Banco de dados para desenvolvimento
LOG_LEVEL=info

📋 Copiar

// jest.config.js
module.exports = {
  // Define os padrões para encontrar arquivos de teste
  testMatch: [
    "/tests//.test.js"
  ],
  // Garante que os testes rodem em um ambiente Node.js
  testEnvironment: "node",
  // Ignora o diretório node_modules e outros padrões
  testPathIgnorePatterns: [
    "/node_modules/"
  ],
  // Executa um script antes de todos os testes
  setupFiles: ["dotenv/config"],
  // Fornece um mapeamento para aliases de módulos, se necessário
  moduleNameMapper: {
    "^@src/(.)$": "/src/$1"
  }
};

📋 Copiar

{
  "name": "api-test-demo",
  "version": "1.0.0",
  "description": "Demonstracao de testes de unidade, integracao e E2E para APIs.",
  "main": "src/app.js",
  "scripts": {
    "start": "cross-env NODE_ENV=development node src/app.js",
    "test": "cross-env NODE_ENV=test jest --detectOpenHandles --forceExit",
    "test:unit": "cross-env NODE_ENV=test jest tests/unit --detectOpenHandles --forceExit",
    "test:integration": "cross-env NODE_ENV=test jest tests/integration --detectOpenHandles --forceExit",
    "test:e2e": "cross-env NODE_ENV=test jest tests/e2e --detectOpenHandles --forceExit"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "express": "^4.18.2"
  },
  "devDependencies": {
    "cross-env": "^7.0.3",
    "jest": "^29.7.0",
    "supertest": "^6.3.3"
  }
}

📋 Copiar

// src/models/UserModel.js
class User {
    constructor(id, name, email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }
}

// Simula um "repositório" em memória para armazenamento.
// Em um cenário real, isso seria uma interface para um banco de dados (MongoDB, PostgreSQL, etc.).
const users = [];
let nextId = 1;
const save = (user) => {
    // Em um ambiente real, você faria validação aqui antes de salvar
    if (!user.name || !user.email) {
        throw new Error("Nome e email são obrigatórios."); // Exemplo de erro básico
    }
    const newUser = new User(nextId++, user.name, user.email);
    users.push(newUser);
    return newUser;
};
const findById = (id) => {
    return users.find(u => u.id === parseInt(id));
};
const findAll = () => {
    return users;
};
const clearAll = () => {
    users.length = 0; // Limpa o array
    nextId = 1;      // Reseta o contador de ID
};
module.exports = {
    save,
    findById,
    findAll,
    clearAll,
    _getUsers: () => users // Apenas para fins de teste avançado, normalmente não exposto
};

📋 Copiar

// src/services/UserService.js
const UserModel = require('../models/UserModel');

class UserService {
    /* Gera um log profissional. Em um cenário real, usaria uma biblioteca como Winston ou Pino.
      @param {string} level - Nível do log (info, warn, error).
      @param {string} message - Mensagem a ser logada.
     /
    static log(level, message) {
        if (process.env.LOG_LEVEL === 'info' || process.env.LOG_LEVEL === 'warn' || process.env.LOG_LEVEL === 'error') {
             // Simples console.log para fins didáticos, em produção use um logger robusto.
            console.log([${level.toUpperCase()}] ${new Date().toISOString()} - ${message});
        }
    }

    / Cria um novo usuário.
      @param {object} userData - Dados do usuário (name, email).
      @returns {object} O usuário criado.
      @throws {Error} Se os dados forem inválidos.
     /
    static createUser(userData) {
        UserService.log('info', Tentando criar usuário: ${JSON.stringify(userData)});
        // Validação de entrada robusta
        if (!userData || typeof userData.name !== 'string' || userData.name.trim() === '' ||
            typeof userData.email !== 'string' || !userData.email.includes('@')) {
            UserService.log('warn', Falha na validação de dados para criar usuário.);
            throw new Error('Dados de usuário inválidos: nome e email são obrigatórios e devem ser válidos.');
        }
        try {
            const newUser = UserModel.save(userData);
            UserService.log('info', Usuário criado com sucesso: ${newUser.id});
            return newUser;
        } catch (error) {
            UserService.log('error', Erro ao salvar usuário no modelo: ${error.message});
            throw new Error(Falha ao criar usuário: ${error.message}); // Encapsula o erro
        }
    }
    /* Busca um usuário pelo ID.
      @param {string} id - O ID do usuário.
      @returns {object|null} O usuário encontrado ou null.
     /
    static getUserById(id) {
        UserService.log('info', Buscando usuário pelo ID: ${id});
        const user = UserModel.findById(id);
        if (!user) {
            UserService.log('info', Usuário com ID ${id} não encontrado.);
        }
        return user;
    }

    / Retorna todos os usuários.
      @returns {array} Lista de todos os usuários.
     /
    static getAllUsers() {
        UserService.log('info', Buscando todos os usuários.);
        return UserModel.findAll();
    }
}
module.exports = UserService;

📋 Copiar

// src/controllers/UserController.js
const UserService = require('../services/UserService');

class UserController {
    /* Rota para criar um novo usuário.
      @param {object} req - Objeto de requisição Express.
      @param {object} res - Objeto de resposta Express.
     /
    static async createUser(req, res) {
        try {
            const newUser = UserService.createUser(req.body);
            res.status(201).json(newUser);
        } catch (error) {
            // Error handling extraordinário: captura diferentes tipos de erros
            // e retorna respostas HTTP apropriadas.
            if (error.message.includes('Dados de usuário inválidos')) {
                return res.status(400).json({ message: error.message });
            }
            res.status(500).json({ message: 'Erro interno do servidor ao criar usuário.', error: error.message });
        }
    }

    / Rota para obter um usuário pelo ID.
      @param {object} req - Objeto de requisição Express.
      @param {object} res - Objeto de resposta Express.
     /
    static async getUserById(req, res) {
        const { id } = req.params;
        try {
            const user = UserService.getUserById(id);
            if (user) {
                return res.status(200).json(user);
            }
            res.status(404).json({ message: Usuário com ID ${id} não encontrado. });
        } catch (error) {
            res.status(500).json({ message: 'Erro interno do servidor ao buscar usuário.', error: error.message });
        }
    }

    / Rota para obter todos os usuários.
      @param {object} req - Objeto de requisição Express.
      @param {object} res - Objeto de resposta Express.
     /
    static async getAllUsers(req, res) {
        try {
            const users = UserService.getAllUsers();
            res.status(200).json(users);
        } catch (error) {
            res.status(500).json({ message: 'Erro interno do servidor ao buscar usuários.', error: error.message });
        }
    }
}

module.exports = UserController;

    // ... (restante do código)

    class UserService {
        // ... (métodos existentes)
        / Exclui um usuário pelo ID.
          @param {string} id - O ID do usuário.
          @returns {boolean} True se o usuário foi excluído, false caso contrário.
         /
        static deleteUser(id) {
            UserService.log('info', Tentando excluir usuário com ID: ${id});
            const wasRemoved = UserModel.removeById(id);
            if (wasRemoved) {
                UserService.log('info', Usuário com ID ${id} excluído com sucesso.);
            } else {
                UserService.log('warn', Usuário com ID ${id} não encontrado para exclusão.);
            }
            return wasRemoved;
        }
    }
    // ... (exportação)

    // ... (restante do código)

    class UserController {
        // ... (métodos existentes)
        / Rota para excluir um usuário pelo ID.
          @param {object} req - Objeto de requisição Express.
          @param {object} res - Objeto de resposta Express.
         /
        static async deleteUser(req, res) {
            const { id } = req.params;
            try {
                const wasDeleted = UserService.deleteUser(id);
                if (wasDeleted) {
                    return res.status(204).send(); // 204 No Content para exclusão bem-sucedida
                }
                res.status(404).json({ message: Usuário com ID ${id} não encontrado para exclusão. });
            } catch (error) {
                res.status(500).json({ message: 'Erro interno do servidor ao excluir usuário.', error: error.message });
            }
        }
    }
    // ... (exportação)

    // tests/unit/userServiceDelete.test.js
    const UserService = require('../../src/services/UserService');
    const UserModel = require('../../src/models/UserModel');

    // Mantenha o mock do UserModel como no exemplo anterior, mas adicione removeById
    jest.mock('../../src/models/UserModel', () => ({
        save: jest.fn((userData) => ({ id: 1, ...userData })),
        findById: jest.fn((id) => {
            if (id === 1) return { id: 1, name: 'Mock User', email: '[email protected]' };
            return null;
        }),
        findAll: jest.fn(() => [/ ... */]),
        clearAll: jest.fn(),
        removeById: jest.fn((id) => id === 1) // Mock para retornar true se ID for 1, false caso contrário
    }));
    describe('UserService - Testes de Unidade para Exclusão', () => {
        beforeEach(() => {
            UserModel.removeById.mockClear();
        });
        it('deve excluir um usuário existente', () => {
            const result = UserService.deleteUser(1);
            expect(result).toBe(true);
            expect(UserModel.removeById).toHaveBeenCalledWith(1);
        });
        it('deve retornar false se o usuário não for encontrado para exclusão', () => {
            const result = UserService.deleteUser(99);
            expect(result).toBe(false);
            expect(UserModel.removeById).toHaveBeenCalledWith(99);
        });
    });

📋 Copiar

    // ... (restante do código)

    describe('UserController - Testes de Integração', () => {
        beforeEach(() => {
            UserModel.clearAll();
        });
        // ... (testes existentes)
        // Teste para a rota DELETE /api/users/:id - exclusão bem-sucedida
        it('DELETE /api/users/:id deve excluir um usuário e retornar status 204', async () => {
            const user = UserModel.save({ name: 'Frank', email: '[email protected]' }); // Prepara o "banco"
            await request(app)
                .delete(/api/users/${user.id})
                .expect(204); // Espera um status HTTP 204 (No Content)
            // Opcional: Verifica se o usuário foi realmente removido
            const removedUser = UserModel.findById(user.id);
            expect(removedUser).toBeUndefined(); // Ou null, dependendo da sua implementação de findById após exclusão
        });
        // Teste para a rota DELETE /api/users/:id - usuário não encontrado
        it('DELETE /api/users/:id deve retornar status 404 se o usuário não for encontrado para exclusão', async () => {
            await request(app)
                .delete('/api/users/999') // ID que não existe
                .expect(404);
        });
    });

📋 Copiar

    // ... (restante do código)

    describe('Fluxo de Usuário - Testes E2E (API-focused)', () => {
        beforeEach(() => {
            UserModel.clearAll();
        });
        // ... (testes existentes)
        // Novo teste E2E: Criar -> Excluir -> Verificar exclusão
        it('deve permitir criar um usuário, excluí-lo e confirmar que ele não existe mais', async () => {
            // 1. Criar um novo usuário
            const userData = { name: 'Grace', email: '[email protected]' };
            const createResponse = await request(app)
                .post('/api/users')
                .send(userData)
                .expect(201);
            const createdUser = createResponse.body;
            expect(createdUser).toHaveProperty('id');
            // 2. Excluir o usuário criado
            await request(app)
                .delete(/api/users/${createdUser.id})
                .expect(204); // Espera 204 No Content
            // 3. Tentar buscar o usuário excluído por ID e esperar 404
            await request(app)
                .get(/api/users/${createdUser.id})
                .expect(404);
            // 4. Listar todos os usuários e verificar que não há nenhum
            const getAllResponse = await request(app)
                .get('/api/users')
                .expect(200);
            expect(getAllResponse.body).toHaveLength(0); // Lista deve estar vazia
        });
    });

📋 Copiar

npm test

📋 Copiar

🚀 Pronto para a próxima aula?

Continue sua jornada no desenvolvimento de APIs e domine Node.js & Express!

📚 Ver todas as aulas