Globais
O Jest coloca cada um desses métodos e objetos no ambiente global dos seus arquivos de teste. Você não precisar fazer nenhuma importação para poder usá-los. No entanto, se você prefere importá-los explicitamente, basta escrever import {describe, expect, test} from '@jest/globals'
.
Os exemplos de TypeScript desta página só funcionarão como documentados se você importar explicitamente APIs do Jest:
import {expect, jest, test} from '@jest/globals';
Consulte o guia Iniciando para obter detalhes sobre como configurar Jest com TypeScript.
Métodos
- Referência
afterAll(fn, timeout)
afterEach(fn, timeout)
beforeAll(fn, timeout)
beforeEach(fn, timeout)
describe(name, fn)
describe.each(table)(name, fn, timeout)
describe.only(name, fn)
describe.only.each(table)(name, fn)
describe.skip(name, fn)
describe.skip.each(table)(name, fn)
test(name, fn, timeout)
test.concurrent(name, fn, timeout)
test.concurrent.each(table)(name, fn, timeout)
test.concurrent.only.each(table)(name, fn)
test.concurrent.skip.each(table)(name, fn)
test.each(table)(name, fn, timeout)
test.failing(name, fn, timeout)
test.failing.each(name, fn, timeout)
test.only.failing(name, fn, timeout)
test.skip.failing(name, fn, timeout)
test.only(name, fn, timeout)
test.only.each(table)(name, fn)
test.skip(name, fn)
test.skip.each(table)(name, fn)
test.todo(name)
- TypeScript Usage
Referência
afterAll(fn, timeout)
Executa uma função depois que todos os testes neste arquivo forem concluídos. Se a função retorna uma promise ou é um generator, Jest aguarda essa promise resolver antes de continuar.
Opcionalmente, você pode fornecer um timeout
(em milissegundos) para especificar quanto tempo esperar antes de abortar. The default timeout is 5 seconds.
Por exemplo:
Por exemplo:
const globalDatabase = makeGlobalDatabase();
function cleanUpDatabase(db) {
db.cleanUp();
}
afterAll(() => {
cleanUpDatabase(globalDatabase);
});
test('can find things', () => {
return globalDatabase.find('thing', {}, results => {
expect(results.length).toBeGreaterThan(0);
});
});
test('can insert a thing', () => {
return globalDatabase.insert('thing', makeThing(), response => {
expect(response.success).toBeTruthy();
});
});
Se afterAll
está dentro de um bloco describe
, ele é executado ao final do bloco "describe".
Se você deseja executar uma limpeza após cada teste em vez de após todos os testes, use ao invés afterEach
.
Se você deseja executar uma limpeza após cada teste em vez de após todos os testes, use ao invés afterEach
.
afterEach(fn, timeout)
Executa uma função após cada um dos testes deste arquivo completar. Se a função retorna uma promise ou é um generator, Jest aguarda essa promise resolver antes de continuar.
Opcionalmente, você pode fornecer um timeout
(em milissegundos) para especificar quanto tempo esperar antes de abortar. The default timeout is 5 seconds.
Por exemplo:
Por exemplo:
const globalDatabase = makeGlobalDatabase();
function cleanUpDatabase(db) {
db.cleanUp();
}
afterEach(() => {
cleanUpDatabase(globalDatabase);
});
test('can find things', () => {
return globalDatabase.find('thing', {}, results => {
expect(results.length).toBeGreaterThan(0);
});
});
test('can insert a thing', () => {
return globalDatabase.insert('thing', makeThing(), response => {
expect(response.success).toBeTruthy();
});
});
Se afterEach
está dentro de um bloco describe
, ele é executado somente após os testes que estão dentro deste bloco "describe".
Se você deseja executar uma limpeza apenas uma vez, depois que todos os testes são executados, use afterAll
.
Se você deseja executar uma limpeza apenas uma vez, depois que todos os testes são executados, use afterAll
.
beforeAll(fn, timeout)
Executa uma função antes de qualquer um dos testes neste arquivo ser executado. Se a função retornar uma promise ou for um generator, o Jest vai esperar até que ela esteja resolvida para executar os testes.
Opcionalmente, você pode fornecer um timeout
(em milissegundos) para especificar quanto tempo esperar antes de abortar. The default timeout is 5 seconds.
Por exemplo:
Por exemplo:
const globalDatabase = makeGlobalDatabase();
beforeAll(() => {
// Limpa o banco de dados e adiciona alguns dados de teste.
// O Jest aguardará que essa promessa seja resolvida antes de executar os testes.
return globalDatabase.clear().then(() => {
return globalDatabase.insert({testData: 'foo'});
});
});
// Jest irá esperar que essa promessa seja resolvida antes de executar testes.
// Como configuramos o banco de dados apenas uma vez neste exemplo, é importante
//que nossos testes não o modifiquem.
test('can find things', () => {
return globalDatabase.find('thing', {}, results => {
expect(results.length).toBeGreaterThan(0);
});
});
Aqui beforeAll
garante que o banco de dados está configurado antes dos testes serem executados. Se a configuração for síncrona, você pode fazer tudo sem precisar usar o beforeAll
. A chave é que Jest esperará por uma promessa resolver, para que você possa ter configuração assíncrona também.
Se você deseja executar algo antes de cada teste, em vez de antes que qualquer teste seja executado, use beforeEach
.
Se você deseja executar algo antes de cada teste, em vez de antes que qualquer teste seja executado, use beforeEach
.
beforeEach(fn, timeout)
Executa uma função antes que cada um dos testes neste arquivo seja executado. Se a função retornar uma promise ou for um generator, o Jest vai esperar até que ela esteja resolvida para executar os testes.
Opcionalmente, você pode fornecer um timeout
(em milissegundos) para especificar quanto tempo esperar antes de abortar. The default timeout is 5 seconds.
Por exemplo:
Por exemplo:
const globalDatabase = makeGlobalDatabase();
beforeEach(() => {
// Clears the database and adds some testing data.
// Jest irá esperar que essa promessa seja resolvida antes de executar testes.
return globalDatabase.clear().then(() => {
return globalDatabase.insert({testData: 'foo'});
});
});
// Since we only set up the database once in this example, it's important
// that our tests don't modify it. test('can find things', () => {
return globalDatabase.find('thing', {}, results => {
expect(results.length).toBeGreaterThan(0);
});
});
Se beforeEach
está dentro de um bloco describe
, ele é executado para cada teste no bloco "describe".
Se você só precisa executar algum código de configuração uma vez, antes que qualquer teste execute, use ao invés beforeAll
.
Se você só precisa executar algum código de configuração uma vez, antes que qualquer teste execute, use ao invés beforeAll
.
describe(name, fn)
describe(name, fn)
cria um bloco que agrupa vários testes relacionados. Por exemplo, se você tiver um objeto myBeverage
que deve ser delicioso, mas não azedo, você pode testá-lo com:
const myBeverage = {
delicious: true,
sour: false,
};
describe('my beverage', () => {
test('is delicious', () => {
expect(myBeverage.delicious).toBeTruthy();
});
test('is not sour', () => {
expect(myBeverage.sour).toBeFalsy();
});
});
Isso não é necessário - você pode escrever os blocos de teste
diretamente em nível superior. Mas isso pode ser útil se preferir que os seus testes sejam organizados em grupos.
Você também pode aninhar blocos describe
se você tem uma hierarquia de testes:
const binaryStringToNumber = binString => {
if (!/^[01]+$/.test(binString)) {
throw new CustomError('Not a binary number.');
}
return parseInt(binString, 2);
};
describe('binaryStringToNumber', () => {
describe('given an invalid binary string', () => {
test('composed of non-numbers throws CustomError', () => {
expect(() => binaryStringToNumber('abc')).toThrow(CustomError);
});
test('with extra whitespace throws CustomError', () => {
expect(() => binaryStringToNumber(' 100')).toThrow(CustomError);
});
});
describe('given a valid binary string', () => {
test('returns the correct number', () => {
expect(binaryStringToNumber('100')).toBe(4);
});
});
});
describe.each(table)(name, fn, timeout)
Use describe.each
se você continuar duplicando a mesma suíte de testes com dados diferentes. describe.each
permite que você escreva a suíte de testes apenas uma vez passando os dados para cada execução.
describe.each
está disponível com duas APIs:
1. describe.each(table)(name, fn, timeout)
-
table
:Array
de Arrays com os argumentos que serão passados à função do argumentofn
de cada execução. If you pass in a 1D array of primitives, internally it will be mapped to a table i.e.[1, 2, 3] -> [[1], [2], [3]]
. -
name
:String
com o nome da suíte de testes.- Escreva títulos únicos para os testes injetando parâmetros na string com a formatação
printf
:%p
- pretty-format.%s
- String.%d
- Number.%i
- Integer.%f
- Floating point value.%j
- JSON.%o
- Object.%#
- Índice do caso de teste.%%
- sinal de porcentagem único ('%'). Isto não consome nenhum argumento.
- Ou escreva títulos únicos ao injetar propriedades do objeto de teste com uma
$variavel
- Para injetar valores de objetos aninhados, você pode prover um keyPath, por exemplo:
$variavel.caminho.do.valor
- Você pode usar
$#
para injetar o índice do caso de teste - Você não pode usar uma
$variavel
com a formataçãoprintf
com a exceção de%%
- Para injetar valores de objetos aninhados, você pode prover um keyPath, por exemplo:
- Escreva títulos únicos para os testes injetando parâmetros na string com a formatação
-
fn
:Function
the suite of tests to be run, this is the function that will receive the parameters in each row as function arguments. -
Opcionalmente, você pode fornecer um
timeout
(em milissegundos) para especificar quanto tempo esperar antes de abortar a execução. The default timeout is 5 seconds.
Example:
describe.each([
[1, 1, 2],
[1, 2, 3],
[2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
test(`returns ${expected}`, () => {
expect(a + b).toBe(expected);
});
test(`returned value not be greater than ${expected}`, () => {
expect(a + b).not.toBeGreaterThan(expected);
});
test(`returned value not be less than ${expected}`, () => {
expect(a + b).not.toBeLessThan(expected);
});
});
describe.each([
{a: 1, b: 1, expected: 2},
{a: 1, b: 2, expected: 3},
{a: 2, b: 1, expected: 3},
])('.add($a, $b)', ({a, b, expected}) => {
test(`returns ${expected}`, () => {
expect(a + b).toBe(expected);
});
test(`returned value not be greater than ${expected}`, () => {
expect(a + b).not.toBeGreaterThan(expected);
});
test(`returned value not be less than ${expected}`, () => {
expect(a + b).not.toBeLessThan(expected);
});
});
2. describe.each`table`(name, fn, timeout)
table
:Tagged Template Literal
- A primeira linha é o cabeçalho que contém o nome das variáveis de cada coluna separadas por
|
- Uma ou mais linhas de dados declaradas como expressões de template literal usando a sintaxe
${value}
.
- A primeira linha é o cabeçalho que contém o nome das variáveis de cada coluna separadas por
name
:String
o título da suíte de testes. Use uma$variavel
para injetar os dados declarados dentro da expressão tagged template no título da suíte e$#
para acessar o índice de cada linha.- Para injetar valores de objetos aninhados, você pode prover um keyPath, por exemplo:
$variavel.caminho.do.valor
- Para injetar valores de objetos aninhados, você pode prover um keyPath, por exemplo:
fn
:Function
the suite of tests to be run, this is the function that will receive the test data object.- Opcionalmente, você pode fornecer um
timeout
(em milissegundos) para especificar quanto tempo esperar antes de abortar a execução. The default timeout is 5 seconds.
Example:
describe.each`
a | b | expected
${1} | ${1} | ${2}
${1} | ${2} | ${3}
${2} | ${1} | ${3}
`('$a + $b', ({a, b, expected}) => {
test(`returns ${expected}`, () => {
expect(a + b).toBe(expected);
});
test(`returned value not be greater than ${expected}`, () => {
expect(a + b).not.toBeGreaterThan(expected);
});
test(`returned value not be less than ${expected}`, () => {
expect(a + b).not.toBeLessThan(expected);
});
});
describe.only(name, fn)
Você pode usar describe.only
se você deseja executar apenas um bloco "describe":
Se beforeAll
está dentro de um bloco describe
, ele é executado no início do bloco de "describe".
describe.only('my beverage', () => {
test('is delicious', () => {
expect(myBeverage.delicious).toBeTruthy();
});
test('is not sour', () => {
expect(myBeverage.sour).toBeFalsy();
});
});
describe('my other beverage', () => {
// ... will be skipped
});
describe.only.each(table)(name, fn)
Também pode ser chamada com fdescribe.each(table)(name, fn)
e fdescribe.each`table`(name, fn)
Use describe.only.each
se você deseja executar apenas suítes específicas de testes orientadas a dados.
describe.only.each
está disponível com duas APIs:
describe.only.each(table)(name, fn)
describe.only.each([
[1, 1, 2],
[1, 2, 3],
[2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
test(`returns ${expected}`, () => {
expect(a + b).toBe(expected);
});
});
test('will not be run', () => {
expect(1 / 0).toBe(Infinity);
});
describe.only.each`table`(name, fn)
describe.only.each`
a | b | expected
${1} | ${1} | ${2}
${1} | ${2} | ${3}
${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
test('passes', () => {
expect(a + b).toBe(expected);
});
});
test('will not be run', () => {
expect(1 / 0).toBe(Infinity);
});
describe.skip(name, fn)
Também pode ser chamada com xdescribe(name, fn)
You can use describe.skip
if you do not want to run the tests of a particular describe
block:
describe('my beverage', () => {
test('is delicious', () => {
expect(myBeverage.delicious).toBeTruthy();
});
test('is not sour', () => {
expect(myBeverage.sour).toBeFalsy();
});
});
describe.skip('my other beverage', () => {
// ... will be skipped
});
Usar describe.skip
muitas vezes é uma alternativa mais limpa de temporariamente pular um trecho do teste. Beware that the describe
block will still run. If you have some setup that also should be skipped, do it in a beforeAll
or beforeEach
block.
describe.skip.each(table)(name, fn)
Também pode ser chamada com xdescribe.each(table)(name, fn)
e xdescribe.each`table`(name, fn)
Use describe.skip.each
se você deseja parar a execução de uma suíte de testes orientada a dados.
describe.skip.each
está disponível com duas APIs:
describe.skip.each(table)(name, fn)
describe.skip.each([
[1, 1, 2],
[1, 2, 3],
[2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
test(`returns ${expected}`, () => {
expect(a + b).toBe(expected); // will not be run
});
});
test('will be run', () => {
expect(1 / 0).toBe(Infinity);
});
describe.skip.each`table`(name, fn)
describe.skip.each`
a | b | expected
${1} | ${1} | ${2}
${1} | ${2} | ${3}
${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
test('will not be run', () => {
expect(a + b).toBe(expected); // will not be run
});
});
test('will be run', () => {
expect(1 / 0).toBe(Infinity);
});
test(name, fn, timeout)
Também pode ser chamada com it(name, fn, timeout)
Tudo que você precisa em um arquivo de teste é o método test
que executa um teste. Por exemplo, digamos que há uma função inchesOfRain()
que deve ser zero. O teste inteiro poderia ser:
test('did not rain', () => {
expect(inchesOfRain()).toBe(0);
});
O primeiro argumento é o nome do teste; o segundo argumento é uma função que contém as expectativas para testar. O terceiro argumento (opcional) é o timeout
(em milissegundos) que determina o tempo de espera antes da execução ser abortada. The default timeout is 5 seconds.
If a promise is returned from test
, Jest will wait for the promise to resolve before letting the test complete. Por exemplo, digamos que a função fetchBeverageList()
retorna uma promise que é esperada para resolver uma lista que contém o valor lemon
nela. Você pode testar isso com:
test('has lemon in it', () => {
return fetchBeverageList().then(list => {
expect(list).toContain('lemon');
});
});
Even though the call to test
will return right away, the test doesn't complete until the promise resolves. For more details, see Testing Asynchronous Code page.
O Jest também vai esperar caso você forneça um argumento para a função de teste, geralmente chamado done
. This could be handy when you want to test callbacks.