Globals

Em seus arquivos de teste, Jest coloca cada um desses métodos e objetos no ambiente global. Você não tem que dar "require" ou importar nada para usá-los.

Métodos #

Referência #

afterAll(fn) #

Executa uma função depois de concluir todos os testes neste arquivo. Se a função retorna uma promessa, Jest aguarda essa promessa resolver antes de continuar.

Isso muitas vezes é útil se você deseja limpar algum estado de configuração global que é 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 afterAll garante que cleanUpDatabase é chamado após todos os testes serem executados.

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.

afterEach(fn) #

Executa uma função após concluir cada um dos testes neste arquivo. Se a função retorna uma promessa, Jest aguarda essa promessa resolver antes de continuar.

Isso muitas vezes é útil se você deseja limpar algum estado temporário que é criado 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 afterEach garante que cleanUpDatabase É chamado depois que cada teste é executado.

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.

beforeAll(fn) #

Executa uma função antes que qualquer um dos testes neste arquivo seja executado. Se a função retorna uma promessa, Jest aguarda essa promessa resolver antes de executar os testes.

Isso muitas vezes é útil se você deseja configurar algum estado global, que será usado por muitos 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 beforeAll garante que o banco de dados está configurado antes dos testes serem executados. Se a instalação foi síncrona, você poderia fazer isso sem beforeAll. A chave é que Jest esperará por uma promessa resolver, para que você possa ter configuração assíncrona também.

Se beforeAll está dentro de um bloco describe, ele é executado no início do bloco de "describe".

Se você deseja executar algo antes de cada teste, em vez de antes que qualquer teste seja executado, use beforeEach.

beforeEach(fn) #

Executa uma função antes que cada um dos testes neste arquivo seja executado. Se a função retorna uma promessa, Jest aguarda essa promessa resolver antes de executar o teste.

Isso muitas vezes é útil se você deseja redefinir algum estado global, que será usado por muitos 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 beforeEach garante que o banco de dados é redefinido para cada teste.

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.

describe(name, fn) #

describe(name, fn) cria um bloco que agrupa vários testes relacionados em uma "suíte de teste". 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();
  });
});

Isto não é necessário - você pode apenas escrever os blocos de test diretamente no nível superior. Mas isso pode ser útil se você prefere que 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')).toThrowError(CustomError);
    });

    test('with extra whitespace throws CustomError', () => {
      expect(() => binaryStringToNumber('  100')).toThrowError(CustomError);
    });
  });

  describe('given a valid binary string', () => {
    test('returns the correct number', () => {
      expect(binaryStringToNumber('100')).toBe(4);
    });
  });
});

describe.only(name, fn) #

Também sob o pseudônimo: fdescribe(name, fn)

Você pode usar describe.only se você deseja 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.skip(name, fn) #

Também sob o pseudônimo: xdescribe(name, fn)

Você pode usar describe.skip se você não deseja executar um bloco específico "describe":

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 é apenas uma alternativa mais fácil para temporariamente comentar fora um pedaço de testes.

require.requireActual(moduleName) #

Retorna o módulo real em vez de uma simulação (mock, em inglês), ignorando todas as verificações sobre se o módulo deve receber uma implementação de simulação ou não.

require.requireMock(moduleName) #

Retorna um módulo de simulação (mock, em inglês) em vez do módulo real, ignorando todas as verificações sobre se o módulo deve ser exigido normalmente ou não.

test(name, fn) #

Também sob o pseudônimo: it(name, fn)

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.

Se uma promessa é retornada de test, Jest irá aguardar a promessa resolver antes de deixar o teste completar.

Por exemplo, digamos que fetchBeverageList() retorna uma promessa que é esperada resolver em uma lista que contém lemon nela. Você pode testar isso com:

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

Mesmo que a chamada para o test retornará imediatamente, o teste não concluirá até que a promessa também resolva.

test.only(name, fn) #

Também sob os pseudônimos: it.only(name, fn) ou fit(name, fn)

Quando você está depurando uma grande base de código, você muitas vezes só vai querer executar um subconjunto dos testes. Você pode usar .only para especificar quais testes são os únicos que você deseja executar.

Por exemplo, digamos que você tenha estes testes:

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

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

Somente o teste "it is raining" será executado, uma vez que é executado com test.only.

Geralmente você não iria acrescentar código usando test.only no controle de código fonte - você iria usá-lo apenas para depuração, e então removê-lo uma vez que você resolveu os testes quebrados.

test.skip(name, fn) #

Também sob os pseudônimos: it.skip(name, fn) ou xit(name, fn) ou xtest(name, fn)

Quando você está mantendo uma grande base de código, você pode às vezes encontrar um teste que está quebrado temporariamente por algum motivo. Se você deseja ignorar a execução deste teste, mas você não quer simplismente excluir esse código, você pode usar test.skip para especificar alguns testes para ignorar.

Por exemplo, digamos que você tenha estes testes:

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

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

Somente o teste "it is raining" será executado, já que o outro teste é executado com test.skip.

Você poderia simplesmente comentar o teste para fora, mas muitas vezes é um pouco mais agradável de usar test.skip porque ele vai manter a indentação e realce da sintaxe.