Globals · Jest

在您的测试文件，Jest 将这些方法和对象放入全局环境。你不必导入即可使用它们。

方法 #

参考 #

`afterAll(fn)` #

在此文件中的所有测试都完成后，运行的功能。如果函数返回一个承诺，Jest 等待这个保证，在继续之前解决。

这通常是有用的如果你想要清理一些在测试之间共享的全局设置状态。

例如：

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

这里 afterAll 确保那 cleanUpDatabase 调用后运行所有测试。

afterAll 是在 describe 块的内部，它运行在 describe 块结尾。

如果你想要在每个测试后运行一些清理，请使用 afterEach。

`afterEach(fn)` #

在此文件中的每个测试都完成后，运行的功能。如果函数返回一个承诺，Jest 等待这个保证，在继续之前解决。

这通常是有用的如果你想要清理一些在每个测试之间共享的全局设置状态。

例如：

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

这里 afterEach 确保那 cleanUpDatabase 调用后运行每个测试。

afterEach 是在 describe 块的内部，它运行在 describe 块结尾。

如果你想要一些清理只运行一次，在所有测试运行后，使用 afterAll 。

`beforeAll(fn)` #

在此文件中的任何测试运行之前运行一个函数。如果函数返回承诺，Jest在运行测试之前等待该承诺解决。

如果要设置将被许多测试使用的一些全局状态，这通常很有用。

例如：

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

在这里 beforeAll 确保数据库设置运行测试之前。如果设置是同步的, 你可以直接做而不用beforeAll 。关键是Jest将等待承诺解决，所以您也可以进行异步设置。

如果beforeAll在describe块内，则它将在 describe 块的开头运行。

如果要在每次测试之前运行某些操作，而不是在任何测试运行之前运行，请改用beforeEach。

`beforeEach(fn)` #

在此文件中的每个测试运行之前运行一个函数。如果函数返回承诺，Jest在运行测试之前等待该承诺解决。

如果要重置许多测试将使用的全局状态，这通常很有用。

例如：

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

这里，beforeEach确保每个测试重置数据库。

如果beforeEach在describe块内，则它将在 describe 块中为每个测试运行。

如果只需要运行一些设置代码，在任何测试运行之前，请使用beforeAll。

`describe(name, fn)` #

describe(name, fn) 在一个“测试套件”中创建一个将几个相关测试分组在一起的块。例如，如果您有一个myBeverage对象，该对象应该是美味但不酸，您可以通过以下方式测试：

const myBeverage = {
  delicious: true,
  sour: false,
};

describe('my beverage', () => {
  test('is delicious', () => {
    expect(myBeverage.delicious).toBeTruthy();
  });

  test('is not sour', () => {
    expect(myBeverage.sour).toBeFalsy();
  });
});

这不是必需的 - 你可以直接在顶层编写test块。但是，如果您希望将测试组织成组，这可以很方便。

You can also nest describe blocks if you have a hierarchy of tests:

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)` #

还有别名：fdescribe(name, fn)

如果你只想运行一个描述块，你可以使用describe.only：

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)` #

还有别名：xdescribe(name, fn)

如果不想运行特定的描述块，可以使用describe.skip：

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

使用 describe.skip 通常是只是一个更容易选择到暂时注释掉一大块的测试。

`require.requireActual(moduleName)` #

返回实际模块而不是模拟，绕过所有检查模块是否应该接收到模拟实现。

`require.requireMock(moduleName)` #

返回模拟的模块，而不是实际的模块，绕过所有检查模块应否要求是否正常。

`test(name, fn)` #

还有别名：it(name, fn)

测试文件中需要的全部是运行测试的 test方法。例如，假设有一个函数inchesOfRain()应该为零。你的整个测试可能是：

test('did not rain', () => {
  expect(inchesOfRain()).toBe(0);
});

第一个参数是测试名称; 第二个参数是包含测试期望的函数。

如果从test返回承诺，Jest将在等待测试完成之前等待承诺解决。

例如，假设fetchBeverageList()返回一个应该解析为具有lemon的列表的承诺。您可以通过以下方式测试：

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

即使对test的调用将立即返回，测试还没有完成，直到承诺也解决。

`test.only(name, fn)` #

还有别名： it.only(name, fn) 或 fit(name, fn)

当您调试大型代码库时，您通常只想运行一个测试子集。您可以使用 .only指定哪些测试是您要运行的唯一测试。

比如说，你有这些测试︰

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

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

只有"it is raining"的测试将运行，因为它运行 test.only。

通常，您不会使用test.only将代码检查到源代码控制中 - 您将仅使用它进行调试，并在修复了断开的测试后将其删除。

`test.skip(name, fn)` #

还有别名：it.skip(name, fn) 或 xit(name, fn) 或 xtest(name, fn)

当你维护一个很大的代码库时，有时可能会发现一个由于某种原因被暂时破坏的测试。如果你想跳过运行这个测试，但你不想删除这个代码，你可以使用test.skip来指定一些要跳过的测试。

比如说，你有这些测试︰

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

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

只有“it is raining”测试才会运行，因为另一个测试是使用test.skip。

您可以简单地注释测试，但使用 test.skip 通常会更好一点，因为它将保留缩进和语法高亮。

方法 #

参考 #

afterAll(fn) #

afterEach(fn) #

beforeAll(fn) #

beforeEach(fn) #

describe(name, fn) #

describe.only(name, fn) #

describe.skip(name, fn) #

require.requireActual(moduleName) #

require.requireMock(moduleName) #

test(name, fn) #

test.only(name, fn) #

test.skip(name, fn) #