Design Patterns: Developing Testable APIs with Node.js

Criando APIs testáveis com Node.js (Design Patterns)

Introdução:
Neste tutorial, vamos aprender como criar APIs testáveis usando Node.js, focando em design patterns que nos ajudam a escrever código limpo e modular. Testabilidade é uma característica muito importante em desenvolvimento de software, pois nos permite garantir que nosso código funcione corretamente e que possamos fazer alterações sem medo de quebrar outras partes do sistema.

Vamos usar o Node.js como nossa plataforma de desenvolvimento, pois ele é uma excelente escolha para a construção de APIs devido à sua flexibilidade, velocidade e fácil integração com bancos de dados e sistemas externos.

Design Patterns:
Antes de começarmos a programar, é importante entender alguns design patterns que são úteis ao construir APIs testáveis em Node.js.

1. MVC (Model-View-Controller): Este é um padrão de arquitetura muito comum em desenvolvimento web. Ele divide a aplicação em três partes distintas: o Model (modelo), que representa os dados da aplicação; o View (visão), que é a interface com o usuário; e o Controller (controlador), que coordena a interação entre o modelo e a visão. Este padrão ajuda a separar as preocupações e torna o código mais organizado e fácil de manter.

2. Dependency Injection: Este padrão nos permite injetar as dependências de uma classe em vez de criá-las dentro da própria classe. Isso facilita a escrita de testes, pois podemos substituir facilmente as dependências reais por mocks ou stubs durante os testes.

3. Factory Pattern: Este padrão nos permite instanciar objetos sem precisar conhecer os detalhes de como eles são criados. Isso é útil quando queremos desacoplar a criação de objetos e fornecer uma interface mais flexível para instanciá-los.

Estrutura do projeto:
Vamos começar criando a estrutura básica do nosso projeto. Para simplificar, vamos dividir a aplicação em três pastas principais: models (para os modelos de dados), controllers (para os controladores da API) e routes (para as rotas da API). Além disso, criaremos uma pasta tests para os testes unitários da aplicação.

Dentro do projeto, teremos os seguintes arquivos:

• app.js: arquivo principal da aplicação que inicializa o servidor e configura as rotas
• models/: pasta para os modelos de dados
• controllers/: pasta para os controladores da API
• routes/: pasta para definir as rotas da API
• tests/: pasta para os testes unitários

Construindo a API:
Vamos agora começar a construir a nossa API utilizando os design patterns mencionados anteriormente.

1. Model:
   Vamos criar um modelo de dados simples para representar um usuário. Para isso, crie um arquivo user.model.js dentro da pasta models com o seguinte conteúdo:

class UserModel {
  constructor(name, email) {
    this.name = name;
    this.email = email;
  }
}

module.exports = UserModel;

1. Controller:
   Agora vamos criar um controlador para lidar com as requisições relacionadas aos usuários. Para isso, crie um arquivo user.controller.js dentro da pasta controllers com o seguinte conteúdo:

const UserModel = require('../models/user.model');

class UserController {
  constructor(userModel) {
    this.userModel = userModel;
  }

  async createUser(name, email) {
    const newUser = new this.userModel(name, email);
    // salvar usuário no banco de dados
    return newUser;
  }
}

module.exports = UserController;

1. Routes:
   Agora vamos definir as rotas da nossa API. Para isso, crie um arquivo user.routes.js dentro da pasta routes com o seguinte conteúdo:

const express = require('express');
const UserController = require('../controllers/user.controller');

const router = express.Router();
const userController = new UserController();

router.post('/user', async (req, res) => {
  const { name, email } = req.body;
  const newUser = await userController.createUser(name, email);
  res.json(newUser);
});

module.exports = router;

1. App.js:
   Por último, vamos configurar as rotas da nossa API no arquivo app.js:

const express = require('express');
const userRoutes = require('./routes/user.routes');

const app = express();

app.use(express.json());
app.use(userRoutes);

const port = process.env.PORT || 3000;
app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

Testando a API:
Agora que já construímos a estrutura básica da nossa API, vamos escrever alguns testes unitários para garantir que tudo esteja funcionando corretamente. Para isso, crie um arquivo user.controller.test.js dentro da pasta tests com o seguinte conteúdo:

const UserController = require('../controllers/user.controller');

describe('UserController', () => {
  let userController;

  beforeEach(() => {
    userController = new UserController();
  });

  test('createUser should return a new user object', async () => {
    const newUser = await userController.createUser('John Doe', 'john@example.com');
    expect(newUser.name).toBe('John Doe');
    expect(newUser.email).toBe('john@example.com');
  });
});

Agora podemos rodar os testes usando um runner de testes como o Jest para confirmar que nossa API está funcionando corretamente.

Conclusão:
Neste tutorial, aprendemos como criar APIs testáveis com Node.js usando design patterns como MVC, Dependency Injection e Factory Pattern. Estes padrões nos ajudam a escrever código limpo e modular que é fácil de testar e manter. Espero que você tenha achado este tutorial útil e esteja pronto para aplicar estes conceitos em seus próprios projetos. Boa sorte e feliz codificação!