Olá pessoal!

Fui inspirado a escrever este artigo por meus alunos e pupilos. Costumo recomendar que aprendam TypeScript assim que se familiarizarem com o processo de automação de teste em JavaScript . Vamos ver quais são as características de usar TypeScript em sua estrutura de automação de teste em termos de teste de API REST…

Você pode encontrar o código completo de um projeto de teste aqui .

TypeScript

Não vamos nos aprofundar muito no que é o TypeScript e como ele é diferente do JavaScript e declarar o importante - é a linguagem de programação . Mas, muito importante também - depende diretamente do JavaScript (plataforma Node.js ).

O TypeScript é apresentado como um pacote Node.js , então vejo isso apenas como JavaScript com alguns recursos interessantes.

Para saber mais sobre a linguagem em si e o que ela tem a oferecer - visite o site oficial enquanto falamos sobre seus recursos em termos de automação de testes…

Configuração do projeto

Vamos passar pelo processo de criação do projeto de automação de teste no TypeScript :

1. Crie um projeto Node.js.

   npm init -y

2. Instale o pacote TypeScript .

   npm i typescript

3. Gere uma configuração TypeScript padrão para o projeto - tsconfig.json .

   npx tsc --init

O comando acima irá gerar um arquivo de configuração padrão, mas recomendo encurtá-lo bastante para algo assim :

 { "compilerOptions": { "baseUrl": "./", "module": "esnext", "target": "esnext", "sourceMap": false, "moduleResolution": "node", "allowJs": true, "skipLibCheck": true, "resolveJsonModule": true, "allowSyntheticDefaultImports": true, "paths": { "*": ["./*"] } } }

Esta configuração contém o mínimo necessário:

• usa a versão mais recente do EcmaScript ,
• disponibiliza importações JSON,
• permite usar o caminho absoluto nas importações.

Você pode estender sua configuração usando a documentação oficial .

seleção de ferramentas

Você pode usar qualquer ferramenta que o ecossistema Node.js tenha a oferecer, mas, em minha experiência, a maioria dos engenheiros que trabalham com TypeScript escolhe Jest por alguns bons motivos:

• ótimo suporte da comunidade (atualizações, respostas, documentos, exemplos de código),
• configuração flexível.

Anteriormente, eu me divertia usando Mocha + Chai para configurar o núcleo do projeto, mas agora estou me atendo ao Jest também, pois ele contém um executor de testes e uma biblioteca de asserções.

Axios parece ser o cliente HTTP mais popular, então sugiro que esta seja sua escolha também.

Não posso dizer que você é forçado a usar isso para sua configuração, mas estou dizendo que é a coisa usual quando você examina os projetos.

Agora, basta instalar esses pacotes como dependências:

npm i jest axios

Coleções de tipos

Alguns pacotes (como Axios ) contêm tipos TypeScript dentro, mas Jest & Mocha não. Além disso, o Jest requer um pacote ts-jest junto com @types/jest para funcionar corretamente - o primeiro habilita os recursos do TypeScript e o segundo permite que você use o IntelliSense .

Portanto, lembre-se - se você não tiver o recurso de preenchimento automático ao tentar usar alguns dos pacotes - provavelmente está faltando declarações de tipo.

Vamos instalar extensões relacionadas ao TypeScript (pacotes) também:

npm i ts-jest @types/jest

Configuração

Jest requer uma predefinição de configuração ts-jest , portanto, você deve declará-la em seu arquivo de configuração (ou package.json ):

 { "jest": { "preset": "ts-jest" } }

Se você planeja usar o caminho absoluto em um projeto , também precisa ajustar sua configuração:

 { "jest": { "preset": "ts-jest", "moduleDirectories": [ "node_modules", "<rootDir>" ] } }

Esta configuração permite que você execute testes com um simples comando... jest

Portanto, configure seu script de teste em package.json para ser:

 { "scripts": { "test": "jest" } }

Em seguida, execute seus testes a qualquer momento com o comando npm test ou npm run test .

Eu também recomendo que você instale uma extensão Jest Runner se você for um usuário do Visual Studio Code - ela permite que você execute / depure os testes/suítes desejados com apenas um clique. No WebStorm, é um recurso integrado.

Tipos personalizados

O principal recurso que o TypeScript introduz no teste da API REST é... tipos , claro!

Você pode declarar como deve ser o corpo de sua solicitação e resposta, ou seja, nomes chave , tipos de valor e etc

Vamos pegar um servidor Paysis como exemplo - podemos anotar sua carga útil do corpo da solicitação para /auth endpoint como um tipo:

 export type AuthRequestBody = { login: string password: string }

E o mesmo para o corpo da resposta - qual servidor deve enviar para nossa solicitação:

 export type AuthResponseBody = { token?: string message?: string }

Como haveria uma carga útil diferente para cenários de sucesso/falha - você pode marcar as chaves como "opcionais" por meio do " ?" personagem.

Uma vez feito - você pode usar esses tipos para compor solicitações e verificações em seus testes...

Solicitar

No Axios , você pode dizer qual corpo está enviando por meio da configuração de solicitação:

 const payload: AxiosRequestConfig<AuthRequestBody> = { method: 'post', url: '/auth', data: { login: process.env.USERNAME, password: process.env.PASSWORD, }, }

AuthRequestBody em AxiosRequestConfig<AuthRequestBody> significa exatamente isso ☝️

Isso significa que você será forçado a usar a carga que corresponde ao tipo AuthRequestBody fornecido no objeto data . Se você esquecer de definir alguns campos obrigatórios ou definir alguns excessivos, verá um erro.

Resposta

A mesma coisa pode ser feita sobre a resposta também:

 const response: AxiosResponse<AuthResponseBody> = await client.request(payload)

Ele adicionará preenchimento automático ao objeto response.data , para que você possa acessar os campos response.data.token ou response.data.message .

Ferramentas avançadas

Além das coisas simples acima, também é possível gerar um esquema JSON de seus tipos personalizados . Ele permite que você não verifique todas as chaves em um corpo de resposta para ver se ele corresponde ao esquema, mas verifique toda a carga útil .

Então a ideia é:

1. Gere um esquema JSON de tipos personalizados.
2. Use um correspondente personalizado toMatchSchema para validar o corpo da resposta.

Coisas muito legais, mas lembre-se de que seus testes podem ficar instáveis após essas alterações - isso acontece quando alguns campos adicionais aparecem, então você precisa atualizar o esquema regularmente.

Conclusão

A configuração do TypeScript pode ser complicada, especialmente se for sua primeira vez, mas vale a pena!

Se você cobrir seus dados de entrada e saída com tipos - não há como cometer um erro de digitação ou algum outro erro de sintaxe ao analisar esses objetos. Ele evita erros simples e permite que você veja a estrutura de suas solicitações diretamente no seu código, para que você não precise abrir nenhuma coleção HTTP (como Postman ) e procurar a solicitação necessária para ver qual corpo ela solicita/responde com.

Deixe-me saber sobre sua experiência e o que você pensa sobre isso.