Ir para o conteúdo principal
Versão: 30.0

Globais

Tradução Beta Não Oficial

Esta página foi traduzida por PageTurner AI (beta). Não é oficialmente endossada pelo projeto. Encontrou um erro? Reportar problema →

Nos seus arquivos de teste, o Jest disponibiliza cada um desses métodos e objetos no ambiente global. Você não precisa importar ou requerer nada para usá-los. Porém, se preferir imports explícitos, pode usar import {describe, expect, test} from '@jest/globals'.

Tradução Beta Não Oficial

Esta página foi traduzida por PageTurner AI (beta). Não é oficialmente endossada pelo projeto. Encontrou um erro? Reportar problema →

"message": "informação"

Os exemplos em TypeScript desta página só funcionarão conforme documentado se você importar explicitamente as APIs do Jest:

import {expect, jest, test} from '@jest/globals';

Consulte o guia Primeiros Passos para detalhes sobre como configurar o Jest com TypeScript.

Métodos​

Referência​

afterAll(fn, timeout)​

Executa uma função após todos os testes deste arquivo serem concluídos. Se a função retornar uma promise ou for um generator, o Jest aguarda essa promise ser resolvida antes de continuar.

Opcionalmente, você pode fornecer um timeout (em milissegundos) para especificar quanto tempo esperar antes de abortar. O tempo limite padrão é de 5 segundos.

Isso é frequentemente útil para limpar algum estado global compartilhado entre testes.

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();
  });
});

Aqui o afterAll garante que cleanUpDatabase seja chamado após todos os testes executarem.

Se afterAll estiver dentro de um bloco describe, ele executa ao final desse bloco describe.

Se quiser executar uma limpeza após cada teste em vez de após todos os testes, use afterEach.

afterEach(fn, timeout)​

Executa uma função após cada um dos testes deste arquivo ser concluído. Se a função retornar uma promise ou for um generator, o Jest aguarda essa promise ser resolvida antes de continuar.

Opcionalmente, você pode fornecer um timeout (em milissegundos) para especificar quanto tempo esperar antes de abortar. O tempo limite padrão é de 5 segundos.

Isso é frequentemente útil para limpar estados temporários criados por cada teste.

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();
  });
});

Aqui o afterEach garante que cleanUpDatabase seja chamado após cada teste executar.

Se afterEach estiver dentro de um bloco describe, ele só executa após os testes dentro desse bloco describe.

Se quiser executar uma limpeza apenas uma vez, após todos os testes, use afterAll.

beforeAll(fn, timeout)​

Executa uma função antes de qualquer teste deste arquivo rodar. Se a função retornar uma promise ou for um generator, o Jest aguarda essa promise ser resolvida antes de executar os testes.

Opcionalmente, você pode fornecer um timeout (em milissegundos) para especificar quanto tempo esperar antes de abortar. O tempo limite padrão é de 5 segundos.

Isso é frequentemente útil para configurar estados globais que serão usados por vários testes.

Por exemplo:

const globalDatabase = makeGlobalDatabase();

beforeAll(() => {
  // Clears the database and adds some testing data.
  // Jest will wait for this promise to resolve before running tests.
  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);
  });
});

Aqui o beforeAll garante que o banco de dados seja configurado antes dos testes rodarem. Se a configuração fosse síncrona, você poderia fazer isso sem beforeAll. O ponto chave é que o Jest aguardará a resolução de uma promise, permitindo configurações assíncronas.

Se beforeAll estiver dentro de um bloco describe, ele executa no início desse bloco describe.

Se quiser executar algo antes de cada teste em vez de antes de qualquer teste, use beforeEach.

beforeEach(fn, timeout)​

Executa uma função antes de cada teste deste arquivo rodar. Se a função retornar uma promise ou for um generator, o Jest aguarda essa promise ser resolvida antes de executar o teste.

Opcionalmente, você pode fornecer um timeout (em milissegundos) para especificar quanto tempo esperar antes de abortar. O tempo limite padrão é de 5 segundos.

Isso é frequentemente útil para redefinir estados globais que serão usados por vários testes.

Por exemplo:

const globalDatabase = makeGlobalDatabase();

beforeEach(() => {
  // Clears the database and adds some testing data.
  // Jest will wait for this promise to resolve before running tests.
  return globalDatabase.clear().then(() => {
    return globalDatabase.insert({testData: 'foo'});
  });
});

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();
  });
});

Aqui o beforeEach garante que o banco de dados seja redefinido para cada teste.

Se o beforeEach estiver dentro de um bloco describe, ele será executado para cada teste dentro desse bloco.

Se você só precisa executar algum código de configuração uma única vez, antes de qualquer teste rodar, use beforeAll em vez disso.

describe(name, fn)​

describe(name, fn) cria um bloco que agrupa vários testes relacionados. Por exemplo, se você tem um objeto myBeverage que deve ser delicioso mas não azedo, você poderia 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 é obrigatório - você pode escrever blocos test diretamente no nível superior. Mas pode ser útil se você prefere organizar seus testes em grupos.

Você também pode aninhar blocos describe se tiver 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ê repete os mesmos conjuntos de testes com dados diferentes. describe.each permite escrever o conjunto de testes uma vez e passar os dados.

describe.each está disponível com duas APIs:

1. describe.each(table)(name, fn, timeout)​

  • table: Array de Arrays com os argumentos passados para fn em cada linha. Se você passar um array unidimensional de primitivos, internamente será mapeado para uma tabela, ex: [1, 2, 3] -> [[1], [2], [3]].

  • name: String o título do conjunto de testes.

    • Gere títulos de teste únicos injetando parâmetros posicionalmente com 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.
      • %$ - Número do caso de teste.
      • %% - sinal de porcentagem único ('%'). Isso não consome um argumento.
    • Ou gere títulos de teste únicos injetando propriedades do objeto de caso de teste com $variable
      • Para injetar valores de objetos aninhados, você pode fornecer um caminho de chave, ou seja, $variable.path.to.value (funciona apenas para propriedades "próprias", por exemplo, $variable.constructor.name não funcionaria)
      • Você pode usar $# para injetar o índice do caso de teste
      • Você não pode usar $variable com a formatação printf, exceto para %%

  • fn: Function o conjunto de testes a ser executado, recebendo os parâmetros de cada linha como argumentos.

  • Opcionalmente, você pode fornecer um timeout (em milissegundos) para especificar quanto tempo esperar por cada linha antes de abortar. O tempo limite padrão é de 5 segundos.

Exemplo:

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

    • Primeira linha com cabeçalhos de nomes de variáveis separados por |
    • Linhas subsequentes com dados usando expressões ${value}.

  • name: String com o título do conjunto de testes, use $variable para injetar dados de teste no título a partir das expressões do template, e $# para o índice da linha.

    • Para injetar valores de objetos aninhados, forneça um keyPath como $variable.path.to.value (funciona apenas para propriedades "próprias", ex: $variable.constructor.name não funcionaria)

  • fn: Function o conjunto de testes a ser executado, recebendo o objeto de dados de teste.

  • Opcionalmente, você pode fornecer um timeout (em milissegundos) para especificar quanto tempo esperar por cada linha antes de abortar. O tempo limite padrão é de 5 segundos.

Exemplo:

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)​

Também conhecido como: fdescribe(name, fn)

Você pode usar describe.only se quiser executar apenas um bloco 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 conhecido como: fdescribe.each(table)(name, fn) e fdescribe.each`table`(name, fn)

Use describe.only.each se quiser executar apenas conjuntos de testes específicos de testes orientados por 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 conhecido como: xdescribe(name, fn)

Você pode usar describe.skip se não quiser executar os testes de um bloco describe específico:

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 geralmente é uma alternativa mais limpa do que comentar temporariamente um trecho de testes. Esteja ciente de que o bloco describe ainda será executado. Se você tiver alguma configuração que também deve ser ignorada, faça isso em um bloco beforeAll ou beforeEach.

describe.skip.each(table)(name, fn)​

Também conhecido como: xdescribe.each(table)(name, fn) e xdescribe.each`table`(name, fn)

Use describe.skip.each se quiser parar de executar um conjunto de testes orientados por 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 conhecido como: 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 existe uma função inchesOfRain() que deve ser zero. Todo o seu teste 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 a serem testadas. O terceiro argumento (opcional) é timeout (em milissegundos) para especificar quanto tempo esperar antes de abortar. O tempo padrão é de 5 segundos.

Se uma promise for retornada de test, o Jest aguardará até que a promise seja resolvida antes de completar o teste. Por exemplo, digamos que fetchBeverageList() retorne uma promise que deve se resolver para uma lista que contenha lemon. Você pode testar isso com:

test('has lemon in it', () => {
  return fetchBeverageList().then(list => {
    expect(list).toContain('lemon');
  });
});

Mesmo que a chamada para test retorne imediatamente, o teste não é concluído até que a promise seja resolvida. Para mais detalhes, consulte a página Testando Código Assíncrono.

O Jest também aguardará se você fornecer um argumento para a função de teste, geralmente chamado done. Isso pode ser útil quando você quer testar callbacks.

test.concurrent(name, fn, timeout)​

Também conhecido como: it.concurrent(name, fn, timeout)

test.concurrent é considerado experimental - veja aqui para detalhes sobre funcionalidades ausentes e outros problemas.

Use test.concurrent se quiser que o teste seja executado concorrentemente.

O primeiro argumento é o nome do teste; o segundo argumento é uma função assíncrona que contém as expectativas a serem testadas. O terceiro argumento (opcional) é timeout (em milissegundos) para especificar quanto tempo esperar antes de abortar. O tempo limite padrão é de 5 segundos.

test.concurrent('addition of 2 numbers', async () => {
  expect(5 + 3).toBe(8);
});

test.concurrent('subtraction 2 numbers', async () => {
  expect(5 - 3).toBe(2);
});
"message": "dica"

Use a opção de configuração maxConcurrency para impedir que o Jest execute mais do que a quantidade especificada de testes simultaneamente.

test.concurrent.each(table)(name, fn, timeout)​

Também disponível como alias: it.concurrent.each(table)(name, fn, timeout)

Use test.concurrent.each se você repete o mesmo teste com dados diferentes. test.each permite escrever o teste uma vez e passar os dados, sendo todos executados de forma assíncrona.

test.concurrent.each está disponível em duas APIs:

1. test.concurrent.each(table)(name, fn, timeout)​

  • table: Array de Arrays com os argumentos passados para a função fn em cada linha. Se passar um array 1D de primitivos, internamente será mapeado para uma tabela, ex: [1, 2, 3] -> [[1], [2], [3]]

  • name: String com o título do bloco de teste.

    • Gere títulos únicos injetando parâmetros posicionalmente com formatação printf:
      • %p - pretty-format.
      • %s- String.
      • %d- Número.
      • %i - Inteiro.
      • %f - Valor de ponto flutuante.
      • %j - JSON.
      • %o - Objeto.
      • %# - Índice do caso de teste.
      • %$ - Número do caso de teste.
      • %% - sinal de percentual único ('%'). Não consome um argumento.

  • fn: Function contendo o teste a ser executado (recebe os parâmetros de cada linha como argumentos). Deve ser uma função assíncrona.

  • Opcionalmente, você pode fornecer um timeout (em milissegundos) para especificar quanto tempo esperar por cada linha antes de abortar. O tempo limite padrão é de 5 segundos.

Exemplo:

test.concurrent.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', async (a, b, expected) => {
  expect(a + b).toBe(expected);
});

2. test.concurrent.each`table`(name, fn, timeout)​

  • table: Tagged Template Literal

    • Primeira linha com cabeçalhos de nomes de variáveis separados por |
    • Linhas subsequentes com dados usando expressões ${value}.

  • name: String título do teste, use $variable para injetar dados no título a partir das expressões do template

    • Para valores aninhados use keyPath ex: $variable.path.to.value (funciona apenas para propriedades "próprias"), por exemplo, $variable.constructor.name não funcionaria

  • fn: Function contendo o teste a ser executado (recebe um objeto de dados do teste). Deve ser uma função assíncrona.

  • Opcionalmente, você pode fornecer um timeout (em milissegundos) para especificar quanto tempo esperar por cada linha antes de abortar. O tempo limite padrão é de 5 segundos.

Exemplo:

test.concurrent.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', async ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

test.concurrent.only.each(table)(name, fn)​

Também disponível como alias: it.concurrent.only.each(table)(name, fn)

Use test.concurrent.only.each para executar apenas testes específicos com diferentes dados de forma concorrente.

test.concurrent.only.each está disponível em duas APIs:

test.concurrent.only.each(table)(name, fn)​

test.concurrent.only.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', async (a, b, expected) => {
  expect(a + b).toBe(expected);
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.only.each`table`(name, fn)​

test.concurrent.only.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', async ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.concurrent.skip.each(table)(name, fn)​

Também disponível como alias: it.concurrent.skip.each(table)(name, fn)

Use test.concurrent.skip.each se você quiser parar de executar uma coleção de testes assíncronos orientados a dados.

test.concurrent.skip.each está disponível com duas APIs:

test.concurrent.skip.each(table)(name, fn)​

test.concurrent.skip.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', async (a, b, expected) => {
  expect(a + b).toBe(expected); // will not be run
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.concurrent.skip.each`table`(name, fn)​

test.concurrent.skip.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', async ({a, b, expected}) => {
  expect(a + b).toBe(expected); // will not be run
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.each(table)(name, fn, timeout)​

Também disponível como alias: it.each(table)(name, fn) e it.each`table`(name, fn)

Use test.each quando você repete o mesmo teste com dados diferentes. test.each permite escrever o teste uma vez e passar os dados.

test.each está disponível com duas APIs:

1. test.each(table)(name, fn, timeout)​

  • table: Array de Arrays com os argumentos passados para a função fn em cada linha. Se passar um array 1D de primitivos, internamente será mapeado para uma tabela, ex: [1, 2, 3] -> [[1], [2], [3]]

  • name: String título do bloco de teste.

    • Gere títulos únicos injetando parâmetros com formatação printf:
      • %p - pretty-format.
      • %s- String.
      • %d- Número.
      • %i - Inteiro.
      • %f - Valor ponto flutuante.
      • %j - JSON.
      • %o - Objeto.
      • %# - Índice do caso de teste.
      • %$ - Número do caso de teste.
      • %% - sinal de percentual único ('%'). Não consome argumento.
    • Ou gere títulos únicos injetando propriedades do objeto com $variable
      • Para valores aninhados use keyPath ex: $variable.path.to.value (funciona apenas para propriedades "próprias", ex: $variable.constructor.name não funcionaria)
      • Use $# para injetar o índice do caso de teste
      • Não é possível usar $variable com formatação printf exceto para %%

  • fn: Function teste a ser executado, recebe os parâmetros de cada linha como argumentos.

  • Opcionalmente, você pode fornecer um timeout (em milissegundos) para especificar quanto tempo esperar por cada linha antes de abortar. O tempo limite padrão é de 5 segundos.

Exemplo:

test.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  expect(a + b).toBe(expected);
});
test.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}) => {
  expect(a + b).toBe(expected);
});

2. test.each`table`(name, fn, timeout)​

  • table: Tagged Template Literal

    • Primeira linha com cabeçalhos de nomes de variáveis separados por |
    • Linhas subsequentes com dados usando expressões ${value}.

  • name: String título do teste, use $variable para injetar dados no título a partir das expressões do template

    • Para valores aninhados use keyPath ex: $variable.path.to.value (funciona apenas para propriedades "próprias"), por exemplo, $variable.constructor.name não funcionaria

  • fn: Function teste a ser executado, recebe o objeto de dados do teste.

  • Opcionalmente, você pode fornecer um timeout (em milissegundos) para especificar quanto tempo esperar por cada linha antes de abortar. O tempo limite padrão é de 5 segundos.

Exemplo:

test.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

test.failing(name, fn, timeout)​

Também disponível como alias: it.failing(name, fn, timeout)

"message": "nota"

Disponível apenas com o runner padrão jest-circus.

Use test.failing quando estiver escrevendo um teste e esperando que ele falhe. Esses testes se comportam de maneira oposta aos testes normais. Se um teste failing lançar algum erro, ele passará. Se não lançar, falhará.

"message": "dica"

Você pode usar esse tipo de teste, por exemplo, ao escrever código de forma BDD. Nesse caso, os testes não aparecerão como falhos até que passem. Então você pode simplesmente remover o modificador failing para fazê-los passar.

Também pode ser uma boa forma de contribuir com testes falhos para um projeto, mesmo que você não saiba como corrigir o bug.

Exemplo:

test.failing('it is not equal', () => {
  expect(5).toBe(6); // this test will pass
});

test.failing('it is equal', () => {
  expect(10).toBe(10); // this test will fail
});

test.failing.each(name, fn, timeout)​

Também disponível como aliases: it.failing.each(table)(name, fn) e it.failing.each`table`(name, fn)

"message": "nota"

Disponível apenas com o runner padrão jest-circus.

Você também pode executar vários testes de uma vez adicionando each após failing.

Exemplo:

test.failing.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}) => {
  expect(a + b).toBe(expected);
});

test.only.failing(name, fn, timeout)​

Também disponível como aliases: it.only.failing(name, fn, timeout), fit.failing(name, fn, timeout)

"message": "nota"

Disponível apenas com o runner padrão jest-circus.

Use test.only.failing se quiser executar apenas um teste falho específico.

test.skip.failing(name, fn, timeout)​

Também disponível como aliases: it.skip.failing(name, fn, timeout), xit.failing(name, fn, timeout), xtest.failing(name, fn, timeout)

"message": "nota"

Disponível apenas com o runner padrão jest-circus.

Use test.skip.failing se quiser pular a execução de um teste falho específico.

test.only(name, fn, timeout)​

Também disponível como aliases: it.only(name, fn, timeout) e fit(name, fn, timeout)

Ao depurar um arquivo de teste grande, você frequentemente desejará executar apenas um subconjunto de testes. Você pode usar .only para especificar quais testes devem ser os únicos executados naquele arquivo.

Opcionalmente, você pode fornecer um timeout (em milissegundos) para especificar quanto tempo esperar antes de abortar. O tempo limite padrão é de 5 segundos.

Por exemplo, suponha estes testes:

test.only('it is raining', () => {
  expect(inchesOfRain()).toBeGreaterThan(0);
});

test('it is not snowing', () => {
  expect(inchesOfSnow()).toBe(0);
});

Apenas o teste "está chovendo" será executado nesse arquivo, pois está marcado com test.only.

Normalmente você não enviaria código com test.only para o controle de versão - use-o apenas para depuração e remova-o após corrigir os testes quebrados.

test.only.each(table)(name, fn)​

Também disponível nos apelidos: it.only.each(table)(name, fn), fit.each(table)(name, fn), it.only.each`table`(name, fn) e fit.each`table`(name, fn)

Use test.only.each se quiser executar apenas testes específicos com diferentes conjuntos de dados.

test.only.each está disponível em duas APIs:

test.only.each(table)(name, fn)​

test.only.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  expect(a + b).toBe(expected);
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.only.each`table`(name, fn)​

test.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}) => {
  expect(a + b).toBe(expected);
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.skip(name, fn)​

Também disponível nos apelidos: it.skip(name, fn), xit(name, fn) e xtest(name, fn)

Ao manter uma base de código grande, você pode encontrar testes temporariamente quebrados. Se quiser pular sua execução sem deletar o código, use test.skip para ignorar testes específicos.

Por exemplo, suponha estes testes:

test('it is raining', () => {
  expect(inchesOfRain()).toBeGreaterThan(0);
});

test.skip('it is not snowing', () => {
  expect(inchesOfSnow()).toBe(0);
});

Apenas o teste "it is raining" será executado, pois o outro usa test.skip.

Você poderia comentar o teste, mas test.skip é mais elegante pois mantém indentação e destaque de sintaxe.

test.skip.each(table)(name, fn)​

Também disponível nos apelidos: it.skip.each(table)(name, fn), xit.each(table)(name, fn), xtest.each(table)(name, fn), it.skip.each`table`(name, fn), xit.each`table`(name, fn) e xtest.each`table`(name, fn)

Use test.skip.each para parar a execução de uma coleção de testes baseados em dados.

test.skip.each está disponível em duas APIs:

test.skip.each(table)(name, fn)​

test.skip.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  expect(a + b).toBe(expected); // will not be run
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.skip.each`table`(name, fn)​

test.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}) => {
  expect(a + b).toBe(expected); // will not be run
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.todo(name)​

Também disponível no apelido: it.todo(name)

Use test.todo para planejar testes futuros. Eles aparecerão destacados no resumo final para acompanhar quantos testes faltam implementar.

const add = (a, b) => a + b;

test.todo('add should be associative');

test.todo lançará um erro se receber uma função de callback. Use test.skip caso já tenha implementado o teste mas não queira executá-lo.

Uso com TypeScript​

Tradução Beta Não Oficial

Esta página foi traduzida por PageTurner AI (beta). Não é oficialmente endossada pelo projeto. Encontrou um erro? Reportar problema →

"message": "informação"

Os exemplos em TypeScript desta página só funcionarão conforme documentado se você importar explicitamente as APIs do Jest:

import {expect, jest, test} from '@jest/globals';

Consulte o guia Primeiros Passos para detalhes sobre como configurar o Jest com TypeScript.

.each​

O modificador .each oferece diferentes formas de definir tabelas de casos de teste. Algumas APIs possuem particularidades na inferência de tipos dos argumentos passados para callbacks de describe ou test. Vamos analisar cada uma:

Para simplicidade, usamos test.each nos exemplos, mas a inferência de tipos é idêntica em todos os casos onde .each é aplicável: describe.each, test.concurrent.only.each, test.skip.each, etc.

Array de objetos​

A API de array de objetos é mais detalhada, mas simplifica a inferência de tipos. A table pode ser inline:

import {test} from '@jest/globals';

test.each([
  {name: 'a', path: 'path/to/a', count: 1, write: true},
  {name: 'b', path: 'path/to/b', count: 3},
])('inline table', ({name, path, count, write}) => {
  // arguments are typed as expected, e.g. `write: boolean | undefined`
});

Ou declarada separadamente como variável:

import {test} from '@jest/globals';

const table = [
  {a: 1, b: 2, expected: 'three', extra: true},
  {a: 3, b: 4, expected: 'seven', extra: false},
  {a: 5, b: 6, expected: 'eleven'},
];

test.each(table)('table as a variable', ({a, b, expected, extra}) => {
  // again everything is typed as expected, e.g. `extra: boolean | undefined`
});

Array de arrays​

O estilo de array de arrays funciona bem com tabelas inline:

import {test} from '@jest/globals';

test.each([
  [1, 2, 'three', true],
  [3, 4, 'seven', false],
  [5, 6, 'eleven'],
])('inline table example', (a, b, expected, extra) => {
  // arguments are typed as expected, e.g. `extra: boolean | undefined`
});

Porém, se a tabela for declarada como variável separada, deve ser tipada como array de tuplas para inferência correta (exceto quando todos elementos da linha forem do mesmo tipo):

import {test} from '@jest/globals';

const table: Array<[number, number, string, boolean?]> = [
  [1, 2, 'three', true],
  [3, 4, 'seven', false],
  [5, 6, 'eleven'],
];

test.each(table)('table as a variable example', (a, b, expected, extra) => {
  // without the annotation types are incorrect, e.g. `a: number | string | boolean`
});

Template literal​

Se todos os valores de entrada forem do mesmo tipo, a API de template literal irá tipar os argumentos corretamente:

import {test} from '@jest/globals';

test.each`
  a    | b    | expected
  ${1} | ${2} | ${3}
  ${3} | ${4} | ${7}
  ${5} | ${6} | ${11}
`('template literal example same type', ({a, b, expected}) => {
  // all arguments are of type `number` because all inputs (a, b, expected) are of type `number`
});

Se as entradas tiverem tipos diferentes, os argumentos serão tipados como uma união de todos os tipos de entrada (ou seja, tipo das variáveis dentro do template literal):

import {test} from '@jest/globals';

test.each`
  a    | b    | expected
  ${1} | ${2} | ${'three'}
  ${3} | ${4} | ${'seven'}
  ${5} | ${6} | ${'eleven'}
`('template literal example different types', ({a, b, expected}) => {
  // all arguments are of type `number | string` because some inputs (a, b) are of type `number` and some others (expected) are of type `string`
});

Caso contrário, se você quiser que cada argumento tenha o tipo correto, você deve fornecer explicitamente o argumento de tipo genérico:

import {test} from '@jest/globals';

test.each<{a: number; b: number; expected: string; extra?: boolean}>`
  a    | b    | expected    | extra
  ${1} | ${2} | ${'three'}  | ${true}
  ${3} | ${4} | ${'seven'}  | ${false}
  ${5} | ${6} | ${'eleven'}
`('template literal example', ({a, b, expected, extra}) => {
  // all arguments are typed as expected, e.g. `a: number`, `expected: string`, `extra: boolean | undefined`
});
cuidado

Tenha em mente que as variáveis dentro do template literal não são verificadas quanto ao tipo, então você precisa garantir que seus tipos estejam corretos.

import {test} from '@jest/globals';

test.each<{a: number; expected: string}>`
  a                            | expected
  ${1}                         | ${'one'}
  ${'will not raise TS error'} | ${'two'}
  ${3}                         | ${'three'}
`('template literal with wrongly typed input', ({a, expected}) => {
  // all arguments are typed as stated in the generic: `a: number`, `expected: string`
  // WARNING: `a` is of type `number` but will be a string in the 2nd test case.
});