全局变量

在您的测试文件中，Jest将每个方法和对象放入全局环境中。您不需要要求或导入任何东西来使用它们。但是，如果您喜欢显式导入，可以这样做import {describe, expect, test} from ` @jest/globals `。

方法

• 毕竟(fn,超时)
• afterEach (fn,超时)
• beforeAll (fn,超时)
• beforeEach (fn,超时)
• 描述(名称、fn)
• describe.each(表)(名称、fn超时)
• describe.only (的名字,fn)
• describe.only.each(表)(名称、fn)
• describe.skip (的名字,fn)
• describe.skip.each(表)(名称、fn)
• 测试(名称、fn超时)
• test.concurrent(的名字,fn,超时)
• test.concurrent.each(表)(名称、fn超时)
• test.concurrent.only.each(表)(名称、fn)
• test.concurrent.skip.each(表)(名称、fn)
• test.each(表)(名称、fn超时)
• test.only (的名字,fn,超时)
• test.only.each(表)(名称、fn)
• test.skip (的名字,fn)
• test.skip.each(表)(名称、fn)
• test.todo(名字)

参考

毕竟(fn,超时)

在此文件中的所有测试完成后运行函数。如果函数返回一个承诺或者是一个生成器，Jest会等待这个承诺解决后再继续。

可选地，您可以提供超时(以毫秒为单位)指定在中止之前需要等待多长时间。注意:默认超时时间为5秒。

如果您想要清除一些跨测试共享的全局设置状态，这通常是有用的。

例如:

常量globalDatabase = makeGlobalDatabase ();函数cleanUpDatabase(db){db.cleanUp ();}毕竟(()= >{cleanUpDatabase (globalDatabase);});测试(“能找到的东西”， () => {返回globalDatabase.find (“东西”，{}，结果=> {expect(result .length).toBeGreaterThan(0);});});测试(“可以插入一个东西”， () => {返回globalDatabase.insert (“东西”， makeThing()， response => {expect(response.success).toBeTruthy();});});

在这里,毕竟确保cleanUpDatabase在所有测试运行后调用。

如果毕竟是在一个描述块，它运行在描述块的末尾。

如果要在每个测试之后而不是在所有测试之后运行一些清理，请使用afterEach代替。

afterEach (fn,超时)

在这个文件中的每个测试完成后运行一个函数。如果函数返回一个承诺或者是一个生成器，Jest会等待这个承诺解决后再继续。

可选地，您可以提供超时(以毫秒为单位)指定在中止之前需要等待多长时间。注意:默认超时时间为5秒。

如果您想清理每个测试创建的一些临时状态，这通常是有用的。

例如:

常量globalDatabase = makeGlobalDatabase ();函数cleanUpDatabase(db){db.cleanUp ();} afterEach (()= >{cleanUpDatabase (globalDatabase);});测试(“能找到的东西”， () => {返回globalDatabase.find (“东西”，{}，结果=> {expect(result .length).toBeGreaterThan(0);});});测试(“可以插入一个东西”， () => {返回globalDatabase.insert (“东西”， makeThing()， response => {expect(response.success).toBeTruthy();});});

在这里,afterEach确保cleanUpDatabase在每次测试运行后调用。

如果afterEach是在一个描述块，它只在该描述块内的测试之后运行。

如果您想只运行一次某些清理，请在所有测试运行之后使用毕竟代替。

beforeAll (fn,超时)

在此文件中的任何测试运行之前运行函数。如果函数返回一个承诺或者是一个生成器，Jest会在运行测试之前等待该承诺的解析。

可选地，您可以提供超时(以毫秒为单位)指定在中止之前需要等待多长时间。注意:默认超时时间为5秒。

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

例如:

常量globalDatabase = makeGlobalDatabase ();beforeAll (()= >{//清除数据库并添加一些测试数据。// Jest将在运行测试之前等待此承诺解决。返回globalDatabase.clear () (()= >{返回globalDatabase.insert ({testData:“foo”});});});//因为在这个例子中我们只设置了一次数据库，所以它很重要//我们的测试不会修改它。测试(“能找到的东西”， () => {返回globalDatabase.find (“东西”，{}，结果=> {expect(result .length).toBeGreaterThan(0);});});

在这里,beforeAll确保在测试运行之前设置好数据库。如果安装是同步的，那么您可以不使用beforeAll。关键是Jest将等待promise来解析，因此您也可以拥有异步设置。

如果beforeAll是在一个描述块，它在描述块的开头运行。

如果您想要在每个测试之前而不是在任何测试之前运行一些东西，请使用beforeEach代替。

beforeEach (fn,超时)

在此文件中的每个测试运行之前运行一个函数。如果函数返回一个承诺或者是一个生成器，Jest会在运行测试之前等待该承诺的解析。

可选地，您可以提供超时(以毫秒为单位)指定在中止之前需要等待多长时间。注意:默认超时时间为5秒。

如果您想重置一些将被许多测试使用的全局状态，这通常是有用的。

例如:

常量globalDatabase = makeGlobalDatabase ();beforeEach (()= >{//清除数据库并添加一些测试数据。// Jest将在运行测试之前等待此承诺解决。返回globalDatabase.clear () (()= >{返回globalDatabase.insert ({testData:“foo”});});});测试(“能找到的东西”， () => {返回globalDatabase.find (“东西”，{}，结果=> {expect(result .length).toBeGreaterThan(0);});});测试(“可以插入一个东西”， () => {返回globalDatabase.insert (“东西”， makeThing()， response => {expect(response.success).toBeTruthy();});});

在这里,beforeEach确保为每个测试重置数据库。

如果beforeEach是在一个描述块，它为描述块中的每个测试运行。

如果您只需要在任何测试运行之前运行一些安装代码一次，请使用beforeAll代替。

描述(名称、fn)

描述(名称、fn)创建一个块，将几个相关的测试分组在一起。例如，如果你有一个myBeverage应该是美味但不酸的东西，你可以用:

常量myBeverage = {美味的:真正的,酸:假};描述(“我的饮料”， () => {test(“很好吃”， () => {expect(myBeverage.delicious).toBeTruthy();});测试(“不是酸”， () => {expect(myBeverage.sour).toBeFalsy();});});

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

你也可以嵌套描述块，如果你有一个测试层次:

常量binaryStringToNumber =binString= >{如果(!/ ^[01] + /美元test (binString)) {扔新CustomError (“不是二进制数字。”);}返回方法用于(binString2);};描述(“binaryStringToNumber”，() =>{描述('给定一个无效的二进制字符串'， () => {test(“由非数字组成抛出CustomError”， () => {()= >binaryStringToNumber (“abc”) .toThrowError (CustomError);});测试('带有额外空格抛出CustomError'， () => {()= >binaryStringToNumber (“100”) .toThrowError (CustomError);});});描述('给定一个有效的二进制字符串'， () => {test('返回正确的数字'， () => {expect(binarystringtonnumber ())“100”) .toBe (4);});});});

describe.each(表)(名称、fn超时)

使用describe.each如果您一直使用不同的数据复制相同的测试套件。describe.each允许您编写测试套件并将数据传递进来。

describe.each提供了两个api:

1.describe.each(表)(名称、fn超时)

• 表格:数组参数传入的数组fn为每一行。
  • 请注意如果传入一个1D数组的原语，它将在内部映射到一个表，即。[1, 2, 3] -> [[1]， [2]， [3]]
• 的名字:字符串测试套件的名称。
  • 通过位置注入参数来生成唯一的测试标题printf格式化:
    • % p-格式。
    • % s——字符串。
    • % d——数字。
    • %我——整数。
    • % f—浮点值。
    • % j- - - - - - JSON。
    • %啊——对象。
    • % #-测试用例索引。
    • % %-单个百分号('%')。这并不消耗参数。
• fn:函数要运行的测试套件，这个函数将接收每行中的参数作为函数参数。
• 可选地，您可以提供超时(以毫秒为单位)，指定在中止前每一行等待多长时间。注意:默认超时时间为5秒。

例子:

describe.each([ [1,1,2]、[1,2,3.]、[2,1,3.]]) (”。添加(%,% i)”， (a, b, expected) => {test(的回报${预期}”， () => {expect(a + b).toBe(expect);});测试('返回值不大于${预期}”， () => {expect(a + b).not.toBeGreaterThan(expect);});测试('返回值不小于${预期}”， () => {expect(a + b).not.toBeLessThan(expect);});});

2.describe.each”表格”(的名字,fn,超时)

• 表格:标记的模板文字
  • 第一行变量名列标题用分隔|
  • 作为模板文字表达式提供的一个或多个后续数据行$ {value}语法。
• 的名字:字符串测试套件的标题，use$变量将测试数据从标记的模板表达式注入到套件标题中。
  • 要注入嵌套的对象值，你可以提供一个键路径。variable.path.to.value美元
• fn:函数要运行的测试套件，这是接收测试数据对象的函数。
• 可选地，您可以提供超时(以毫秒为单位)，指定在中止前每一行等待多长时间。注意:默认超时时间为5秒。

例子:

describe.each预计会是| b |$ {1}|$ {1}|$ {2}$ {1}|$ {2}|$ {3.}$ {2}|$ {1}|$ {3.}”(“a + b美元”， ({a, b, expected}) => {test(的回报${预期}”， () => {expect(a + b).toBe(expect);});测试('返回值不大于${预期}”， () => {expect(a + b).not.toBeGreaterThan(expect);});测试('返回值不小于${预期}”， () => {expect(a + b).not.toBeLessThan(expect);});});

describe.only (的名字,fn)

别名下还有:fdescribe(名称、fn)

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

describe.only (“我的饮料”， () => {test(“很好吃”， () => {expect(myBeverage.delicious).toBeTruthy();});测试(“不是酸”， () => {expect(myBeverage.sour).toBeFalsy();});});描述(“我的其他饮料”， () => {/ /……将被忽略});

describe.only.each(表)(名称、fn)

别名还包括:fdescribe.each(表)(名称、fn)和fdescribe。每个'table”(名称、fn)

使用describe.only.each如果只想运行数据驱动测试的特定测试套件。

describe.only.each提供了两个api:

describe.only.each(表)(名称、fn)

describe.only.each([ [1,1,2]、[1,2,3.]、[2,1,3.]]) (”。添加(%,% i)”， (a, b, expected) => {test(的回报${预期}”， () => {expect(a + b).toBe(expect);});});测试('将不会被运行'， () => {1/0) .toBe (∞);});

describe.only.each”表格”(的名字,fn)

describe.only.each预计会是| b |$ {1}|$ {1}|$ {2}$ {1}|$ {2}|$ {3.}$ {2}|$ {1}|$ {3.}”(当$a被添加到$b时，返回$expected， ({a, b, expected}) => {test(“通过”， () => {expect(a + b).toBe(expect);});});测试('将不会被运行'， () => {1/0) .toBe (∞);});

describe.skip (的名字,fn)

别名下还有:xdescribe(名称、fn)

您可以使用describe.skip如果你不想运行一个特定的描述块:

描述(“我的饮料”， () => {test(“很好吃”， () => {expect(myBeverage.delicious).toBeTruthy();});测试(“不是酸”， () => {expect(myBeverage.sour).toBeFalsy();});});describe.skip (“我的其他饮料”， () => {/ /……将被忽略});

使用describe.skip通常是临时注释掉测试块的一种更简洁的替代方法。

describe.skip.each(表)(名称、fn)

别名还包括:xdescribe.each(表)(名称、fn)和xdescribe。每个'table”(名称、fn)

使用describe.skip.each如果您想停止运行一组数据驱动的测试。

describe.skip.each提供了两个api:

describe.skip.each(表)(名称、fn)

describe.skip.each([ [1,1,2]、[1,2,3.]、[2,1,3.]]) (”。添加(%,% i)”， (a, b, expected) => {test(的回报${预期}”， () => {expect(a + b).toBe(expect);//不会被运行});});测试(会跑的， () => {1/0) .toBe (∞);});

describe.skip.each”表格”(的名字,fn)

describe.skip.each预计会是| b |$ {1}|$ {1}|$ {2}$ {1}|$ {2}|$ {3.}$ {2}|$ {1}|$ {3.}”(当$a被添加到$b时，返回$expected， ({a, b, expected}) => {test('将不会被运行'， () => {expect(a + b).toBe(expect);//不会被运行});});测试(会跑的， () => {1/0) .toBe (∞);});

测试(名称、fn超时)

别名下还有:(名称、fn超时)

在测试文件中所需要的就是测试方法，该方法运行测试。例如，假设有一个函数inchesOfRain ()它应该是零。你的整个测试可能是:

测试(没有下雨的， () => {expect(inchesOfRain()).toBe()0);});

第一个参数是测试名;第二个参数是一个包含要测试的期望的函数。第三个参数(可选)是超时(以毫秒为单位)指定在中止之前需要等待多长时间。注意:默认超时时间为5秒。

注意:如果一个承诺返回从测试， Jest将等待承诺解决后才让测试完成。笑话也会等着你为测试函数提供一个参数,通常称为完成。当您想要测试回调时，这可能很方便。请参阅如何测试异步代码在这里。

比如说fetchBeverageList ()返回一个承诺，该承诺应该解析到一个具有柠檬在里面。你可以用:

测试(“里面有柠檬”， () => {返回fetchBeverageList () (列表= >{期望(列表).toContain (“柠檬”);});});

即使打电话给测试将立即返回，直到promise也解决了，测试才会完成。

test.concurrent(的名字,fn,超时)

别名下还有:它。并发(名称、fn超时)

使用test.concurrent如果您希望测试并发运行。

注意:test.concurrent被认为是实验性的，看到了吗在这里有关丢失的特性和其他问题的详细信息

第一个参数是测试名;第二个参数是一个异步函数，它包含要测试的期望。第三个参数(可选)是超时(以毫秒为单位)指定在中止之前需要等待多长时间。注意:默认超时时间为5秒。

test.concurrent('addition of2number '， async () => {expect()5+3.) .toBe (8);});test.concurrent(“减法2number '， async () => {expect()5-3.) .toBe (2);});

注意:使用maxConcurrency以防止Jest同时执行超过指定数量的测试

test.concurrent.each(表)(名称、fn超时)

别名下还有:it.concurrent.each(表)(名称、fn超时)

使用test.concurrent.each如果你一直用不同的数据重复相同的测试。test.each允许您一次编写测试并传入数据，所有测试都异步运行。

test.concurrent.each提供了两个api:

1.test.concurrent.each(表)(名称、fn超时)

• 表格:数组包含传入测试的参数的数组fn为每一行。
  • 请注意如果传入一个1D数组的原语，它将在内部映射到一个表，即。[1, 2, 3] -> [[1]， [2]， [3]]
• 的名字:字符串测试块的标题。
  • 通过位置注入参数来生成唯一的测试标题printf格式化:
    • % p-格式。
    • % s——字符串。
    • % d——数字。
    • %我——整数。
    • % f—浮点值。
    • % j- - - - - - JSON。
    • %啊——对象。
    • % #-测试用例索引。
    • % %-单个百分号('%')。这并不消耗参数。
• fn:函数要运行的测试，这个函数将接收每一行的参数作为函数参数，这必须是一个异步函数。
• 可选地，您可以提供超时(以毫秒为单位)，指定在中止前每一行等待多长时间。注意:默认超时时间为5秒。

例子:

test.concurrent.each([ [1,1,2]、[1,2,3.]、[2,1,3.]]) (”。添加(%,% i)”， (a, b, expected) => {expect(a + b).toBe(expected);});

2.test.concurrent.each”表格”(的名字,fn,超时)

• 表格:标记的模板文字
  • 第一行变量名列标题用分隔|
  • 作为模板文字表达式提供的一个或多个后续数据行$ {value}语法。
• 的名字:字符串试题的题目，使用$变量将测试数据从标记的模板表达式注入到测试标题。
  • 要注入嵌套的对象值，你可以提供一个键路径。variable.path.to.value美元
• fn:函数要运行的测试，这是接收测试数据对象的函数，这必须是一个异步函数。
• 可选地，您可以提供超时(以毫秒为单位)，指定在中止前每一行等待多长时间。注意:默认超时时间为5秒。

例子:

test.concurrent.each预计会是| b |$ {1}|$ {1}|$ {2}$ {1}|$ {2}|$ {3.}$ {2}|$ {1}|$ {3.}”(当$a被添加到$b时，返回$expected({a, b,预期})= >{期望(a + b) .toBe(预期);});

test.concurrent.only.each(表)(名称、fn)

别名下还有:it.concurrent.only.each(表)(名称、fn)

使用test.concurrent.only.each如果只想用不同的测试数据同时运行特定的测试。

test.concurrent.only.each提供了两个api:

test.concurrent.only.each(表)(名称、fn)

test.concurrent.only.each([ [1,1,2]、[1,2,3.]、[2,1,3.]]) (”。添加(%,% i)”,异步(a, b, expected) => {expect(a + b).toBe(expected);});测试('将不会被运行'， () => {1/0) .toBe (∞);});

test.only.each”表格”(的名字,fn)

test.concurrent.only.each预计会是| b |$ {1}|$ {1}|$ {2}$ {1}|$ {2}|$ {3.}$ {2}|$ {1}|$ {3.}”(当$a被添加到$b时，返回$expected,异步({a, b, expected}) => {expect(a + b).toBe(expected);});测试('将不会被运行'， () => {1/0) .toBe (∞);});

test.concurrent.skip.each(表)(名称、fn)

别名下还有:it.concurrent.skip.each(表)(名称、fn)

使用test.concurrent.skip.each如果要停止运行异步数据驱动测试集合。

test.concurrent.skip.each提供了两个api:

test.concurrent.skip.each(表)(名称、fn)

test.concurrent.skip.each([ [1,1,2]、[1,2,3.]、[2,1,3.]]) (”。添加(%,% i)”,异步(a, b, expected) => {expect(a + b).toBe(expected);//不会被运行});测试(会跑的， () => {1/0) .toBe (∞);});

test.concurrent.skip.each”表格”(的名字,fn)

test.concurrent.skip.each预计会是| b |$ {1}|$ {1}|$ {2}$ {1}|$ {2}|$ {3.}$ {2}|$ {1}|$ {3.}”(当$a被添加到$b时，返回$expected,异步({a, b, expected}) => {expect(a + b).toBe(expected);//不会被运行});测试(会跑的， () => {1/0) .toBe (∞);});

test.each(表)(名称、fn超时)

别名下还有:一般(表)(名称、fn)和它。每个'table”(名称、fn)

使用test.each如果你一直用不同的数据重复相同的测试。test.each允许您只编写一次测试并将数据传递进来。

test.each提供了两个api:

1.test.each(表)(名称、fn超时)

• 表格:数组包含传入测试的参数的数组fn为每一行。
  • 请注意如果传入一个1D数组的原语，它将在内部映射到一个表，即。[1, 2, 3] -> [[1]， [2]， [3]]
• 的名字:字符串测试块的标题。
  • 通过位置注入参数来生成唯一的测试标题printf格式化:
    • % p-格式。
    • % s——字符串。
    • % d——数字。
    • %我——整数。
    • % f—浮点值。
    • % j- - - - - - JSON。
    • %啊——对象。
    • % #-测试用例索引。
    • % %-单个百分号('%')。这并不消耗参数。
• fn:函数要运行的测试，这个函数将接收每一行中的参数作为函数参数。
• 可选地，您可以提供超时(以毫秒为单位)，指定在中止前每一行等待多长时间。注意:默认超时时间为5秒。

例子:

test.each([ [1,1,2]、[1,2,3.]、[2,1,3.]]) (”。添加(%,% i)”， (a, b, expected) => {expect(a + b).toBe(expected);});

2.test.each”表格”(的名字,fn,超时)

• 表格:标记的模板文字
  • 第一行变量名列标题用分隔|
  • 作为模板文字表达式提供的一个或多个后续数据行$ {value}语法。
• 的名字:字符串试题的题目，使用$变量将测试数据从标记的模板表达式注入到测试标题。
  • 要注入嵌套的对象值，你可以提供一个键路径。variable.path.to.value美元
• fn:函数要运行的测试，这是将接收测试数据对象的函数。
• 可选地，您可以提供超时(以毫秒为单位)，指定在中止前每一行等待多长时间。注意:默认超时时间为5秒。

例子:

test.each预计会是| b |$ {1}|$ {1}|$ {2}$ {1}|$ {2}|$ {3.}$ {2}|$ {1}|$ {3.}”(当$a被添加到$b时，返回$expected({a, b,预期})= >{期望(a + b) .toBe(预期);});

test.only (的名字,fn,超时)

别名还包括:它。(名称、fn超时),fit(名称、fn超时)

当您调试一个大型测试文件时，您通常只想运行测试的一个子集。您可以使用只有指定哪些测试是要在该测试文件中运行的唯一测试。

可选地，您可以提供超时(以毫秒为单位)指定在中止之前需要等待多长时间。注意:默认超时时间为5秒。

例如，假设你做了这些测试:

test.only (“下雨了”， () => {expect(inchesOfRain()).toBeGreaterThan()0);});测试(“没有下雪”， () => {expect(inchesOfSnow()).toBe()0);});

只有“it is raining”测试将在该测试文件中运行，因为它是用它运行的test.only。

通常你不会检查代码使用test.only进入源代码管理——你可以使用它进行调试，一旦你修复了坏掉的测试，就可以删除它。

test.only.each(表)(名称、fn)

别名还包括:it.only.each(表)(名称、fn),fit.each(表)(名称、fn),只有。每个'table”(名称、fn)和健康。每个'table”(名称、fn)

使用test.only.each如果您只想使用不同的测试数据运行特定的测试。

test.only.each提供了两个api:

test.only.each(表)(名称、fn)

test.only.each([ [1,1,2]、[1,2,3.]、[2,1,3.]]) (”。添加(%,% i)”， (a, b, expected) => {expect(a + b).toBe(expected);});测试('将不会被运行'， () => {1/0) .toBe (∞);});

test.only.each”表格”(的名字,fn)

test.only.each预计会是| b |$ {1}|$ {1}|$ {2}$ {1}|$ {2}|$ {3.}$ {2}|$ {1}|$ {3.}”(当$a被添加到$b时，返回$expected({a, b,预期})= >{期望(a + b) .toBe(预期);});测试('将不会被运行'， () => {1/0) .toBe (∞);});

test.skip (的名字,fn)

别名还包括:它。跳过(名称、fn),——xit(名称、fn),xtest(名称、fn)

当您维护一个大型代码库时，您有时会发现一个测试由于某种原因暂时中断了。如果您想跳过运行此测试，但又不想删除此代码，您可以使用test.skip指定要跳过的一些测试。

例如，假设你做了这些测试:

测试(“下雨了”， () => {expect(inchesOfRain()).toBeGreaterThan()0);});test.skip (“没有下雪”， () => {expect(inchesOfSnow()).toBe()0);});

只有“it is raining”测试将运行，因为使用的是其他测试test.skip。

您可以对测试进行注释，但通常使用起来会更好一些test.skip因为它会维护缩进和语法高亮显示。

test.skip.each(表)(名称、fn)

别名还包括:it.skip.each(表)(名称、fn),xit.each(表)(名称、fn),xtest.each(表)(名称、fn),it.skip。每个'table”(名称、fn),——xit。每个'table”(名称、fn)和xtest。每个'table”(名称、fn)

使用test.skip.each如果要停止运行数据驱动测试的集合。

test.skip.each提供了两个api:

test.skip.each(表)(名称、fn)

test.skip.each([ [1,1,2]、[1,2,3.]、[2,1,3.]]) (”。添加(%,% i)”， (a, b, expected) => {expect(a + b).toBe(expected);//不会被运行});测试(会跑的， () => {1/0) .toBe (∞);});

test.skip.each”表格”(的名字,fn)

test.skip.each预计会是| b |$ {1}|$ {1}|$ {2}$ {1}|$ {2}|$ {3.}$ {2}|$ {1}|$ {3.}”(当$a被添加到$b时，返回$expected({a, b,预期})= >{期望(a + b) .toBe(预期);//不会被运行});测试(会跑的， () => {1/0) .toBe (∞);});

test.todo(名字)

别名下还有:it.todo(名字)

使用test.todo当您计划编写测试时。这些测试将在最后的摘要输出中突出显示，以便您知道还需要执行多少个测试。

请注意:如果你提供一个测试回调函数，那么test.todo将抛出一个错误。如果您已经实现了测试，并且它被破坏了，并且您不希望它运行，那么使用它test.skip代替。

API

• 的名字:字符串测试计划的标题。

例子:

常量添加=(a、b) = >a + b;test.todo (“add应该是联想的”);