跳到主要内容
版本:27.2

全球的

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

方法#


参考#

毕竟(fn,超时)#

在此文件中的所有测试完成后运行函数。如果函数返回一个承诺或是一个生成器,Jest将等待该承诺得到解决,然后继续。

或者,您可以提供超时(以毫秒为单位)用于指定中止前的等待时间。注意:默认超时为5秒。

如果您想要清除在测试之间共享的某些全局设置状态,这通常很有用。

例如:

常数 全局数据库 = makeGlobalDatabase ( ) ;
作用 清洁数据库 ( 分贝 ) {
分贝 . 清理 ( ) ;
}
毕竟 ( ( ) => {
清洁数据库 ( 全局数据库 ) ;
} ) ;
测验 ( “能找到东西” , ( ) => {
回来 全局数据库 . 发现 ( “事情” , { } , 后果 => {
预料 ( 后果 . ) . ( 0 ) ;
} ) ;
} ) ;
测验 ( “可以插入一个对象” , ( ) => {
回来 全局数据库 . 插入 ( “事情” , 制造 ( ) , 回答 => {
预料 ( 回答 . 成功 ) . 托贝特鲁西 ( ) ;
} ) ;
} ) ;

这是毕竟确保清洁数据库在所有测试运行后调用。

如果毕竟在一个房间里描述块,它运行在描述块的末尾。

如果希望在每次测试之后而不是在所有测试之后运行一些清理,请使用之后相反

每次之后(fn,超时)#

在此文件中的每个测试完成后运行函数。如果函数返回一个承诺或是一个生成器,Jest将等待该承诺得到解决,然后继续。

或者,您可以提供超时(以毫秒为单位)用于指定中止前的等待时间。注意:默认超时为5秒。

如果您想要清除由每个测试创建的一些临时状态,这通常很有用。

例如:

常数 全局数据库 = makeGlobalDatabase ( ) ;
作用 清洁数据库 ( 分贝 ) {
分贝 . 清理 ( ) ;
}
之后 ( ( ) => {
清洁数据库 ( 全局数据库 ) ;
} ) ;
测验 ( “能找到东西” , ( ) => {
回来 全局数据库 . 发现 ( “事情” , { } , 后果 => {
预料 ( 后果 . ) . ( 0 ) ;
} ) ;
} ) ;
测验 ( “可以插入一个对象” , ( ) => {
回来 全局数据库 . 插入 ( “事情” , 制造 ( ) , 回答 => {
预料 ( 回答 . 成功 ) . 托贝特鲁西 ( ) ;
} ) ;
} ) ;

这是之后确保清洁数据库在每次测试运行后调用。

如果之后在一个房间里描述块,它仅在该块内的测试之后运行。

如果只想在所有测试运行后运行一次清理,请使用毕竟相反

之前(fn,超时)#

在运行此文件中的任何测试之前运行函数。如果该函数返回承诺或是生成器,Jest将在运行测试之前等待该承诺得到解析。

或者,您可以提供超时(以毫秒为单位)用于指定中止前的等待时间。注意:默认超时为5秒。

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

例如:

常数 全局数据库 = makeGlobalDatabase ( ) ;
以前 ( ( ) => {
//清除数据库并添加一些测试数据。
//Jest将在运行测试之前等待此承诺得到解决。
回来 全局数据库 . 清楚的 ( ) . 然后 ( ( ) => {
回来 全局数据库 . 插入 ( { 测试数据 : “福” } ) ;
} ) ;
} ) ;
//因为在本例中我们只设置了一次数据库,所以它很重要
//我们的测试不会修改它。
测验 ( “能找到东西” , ( ) => {
回来 全局数据库 . 发现 ( “事情” , { } , 后果 => {
预料 ( 后果 . ) . ( 0 ) ;
} ) ;
} ) ;

这是以前确保在运行测试之前设置数据库。如果安装程序是同步的,则可以不使用以前. 关键是Jest将等待承诺的解决,因此您也可以进行异步设置。

如果以前在一个房间里描述块,它运行在描述块的开头。

如果您想在每次测试之前而不是在任何测试运行之前运行某些东西,请使用之前相反

每次之前(fn,超时)#

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

或者,您可以提供超时(以毫秒为单位)用于指定中止前的等待时间。注意:默认超时为5秒。

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

例如:

常数 全局数据库 = makeGlobalDatabase ( ) ;
之前 ( ( ) => {
//清除数据库并添加一些测试数据。
//Jest将在运行测试之前等待此承诺得到解决。
回来 全局数据库 . 清楚的 ( ) . 然后 ( ( ) => {
回来 全局数据库 . 插入 ( { 测试数据 : “福” } ) ;
} ) ;
} ) ;
测验 ( “能找到东西” , ( ) => {
回来 全局数据库 . 发现 ( “事情” , { } , 后果 => {
预料 ( 后果 . ) . ( 0 ) ;
} ) ;
} ) ;
测验 ( “可以插入一个对象” , ( ) => {
回来 全局数据库 . 插入 ( “事情” , 制造 ( ) , 回答 => {
预料 ( 回答 . 成功 ) . 托贝特鲁西 ( ) ;
} ) ;
} ) ;

这是之前确保为每个测试重置数据库。

如果之前在一个房间里描述块中,它为描述块中的每个测试运行。

如果在运行任何测试之前只需要运行一些设置代码一次,请使用以前相反

描述(名称,fn)#

描述(名称,fn)创建将多个相关测试分组在一起的块。例如,如果您有我的饮料应该是美味但不酸的对象,您可以使用以下方法进行测试:

常数 我的饮料 = {
美味的 : 符合事实的 ,
酸的 : 错误的 ,
} ;
描述 ( “我的饮料” , ( ) => {
测验 ( “很好吃” , ( ) => {
预料 ( 我的饮料 . 美味的 ) . 托贝特鲁西 ( ) ;
} ) ;
测验 ( “不是酸的” , ( ) => {
预料 ( 我的饮料 . 酸的 ) . 托贝尔西 ( ) ;
} ) ;
} ) ;

这不是必需的-您可以编写测验直接在顶层设置块。但是,如果您喜欢将测试组织成小组,那么这将非常方便。

你也可以筑巢描述如果有测试层次结构,则会阻止:

常数 二进制字符串编号 = 宾斯特林 => {
如果 ( ! / ^[01]+$ / . 测验 ( 宾斯特林 ) ) {
刚出现的 自定义错误 ( “不是二进制数。” ) ;
}
回来 帕森特 ( 宾斯特林 , 2. ) ;
} ;
描述 ( “二进制字符串编号” , ( ) => {
描述 ( '给定一个无效的二进制字符串' , ( ) => {
测验 ( '由非数字组成的错误' , ( ) => {
预料 ( ( ) => 二进制字符串编号 ( “abc” ) ) . Tothrowerr ( 自定义错误 ) ;
} ) ;
测验 ( '带额外空格抛出自定义错误' , ( ) => {
预料 ( ( ) => 二进制字符串编号 ( ' 100' ) ) . Tothrowerr ( 自定义错误 ) ;
} ) ;
} ) ;
描述 ( '给定有效的二进制字符串' , ( ) => {
测验 ( '返回正确的数字' , ( ) => {
预料 ( 二进制字符串编号 ( '100' ) ) . 托比 ( 4. ) ;
} ) ;
} ) ;
} ) ;

描述每个(表)(名称、fn、超时)#

使用描述每个如果您继续使用不同的数据复制相同的测试套件。描述每个允许您编写一次测试套件并传入数据。

描述每个提供了两个API:

1.描述每个(表)(名称、fn、超时)#

  • 桌子:大堆具有传递到fn每行。
    • 笔记如果传入一个1D基元数组,它将在内部映射到一个表,即。[1, 2, 3] -> [[1], [2], [3]]
  • 名称:一串测试套件的标题。
    • 通过使用位置注入参数生成唯一的测试标题printf格式化:
      • %p-漂亮的格式.
      • %-绳子。
      • %d-号码。
      • %我-整数。
      • %f-浮点值。
      • %j-JSON。
      • %o-反对。
      • %#-测试用例的索引。
      • %%-单百分号(“%”)。这不会消耗参数。
    • 或者通过将测试用例对象的属性注入$variable
      • 要使用注入嵌套对象值,可以提供键路径,即。$variable.path.to.value
      • 你可以用$#注入测试用例的索引
      • 你不能使用$variableprintf%%
  • fn:作用要运行的测试套件,这是将每行中的参数作为函数参数接收的函数。
  • 或者,您可以提供超时(以毫秒为单位)用于指定在中止前等待每行的时间。注意:默认超时为5秒。

例子:

描述 . 每个 ( [
[ 1. , 1. , 2. ] ,
[ 1. , 2. , 3. ] ,
[ 2. , 1. , 3. ] ,
] ) ( “.添加(%i,%i)” , ( A. , B , 预期 ) => {
测验 ( ` 返回 ${ 预期 } ` , ( ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ;
} ) ;
测验 ( ` 返回值不能大于 ${ 预期 } ` , ( ) => {
预料 ( A. + B ) . . ( 预期 ) ;
} ) ;
测验 ( ` 返回值不能小于 ${ 预期 } ` , ( ) => {
预料 ( A. + B ) . . 托布利森 ( 预期 ) ;
} ) ;
} ) ;
描述 . 每个 ( [
{ A. : 1. , B : 1. , 预期 : 2. } ,
{ A. : 1. , B : 2. , 预期 : 3. } ,
{ A. : 2. , B : 1. , 预期 : 3. } ,
] ) ( “.加上($a,$b)” , ( { A. , B , 预期 } ) => {
测验 ( ` 返回 ${ 预期 } ` , ( ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ;
} ) ;
测验 ( ` 返回值不能大于 ${ 预期 } ` , ( ) => {
预料 ( A. + B ) . . ( 预期 ) ;
} ) ;
测验 ( ` 返回值不能小于 ${ 预期 } ` , ( ) => {
预料 ( A. + B ) . . 托布利森 ( 预期 ) ;
} ) ;
} ) ;

2.描述.每个“表”(名称、fn、超时)#

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

例子:

描述 . 每个 `
a | b |预期
${ 1. } | ${ 1. } | ${ 2. }
${ 1. } | ${ 2. } | ${ 3. }
${ 2. } | ${ 1. } | ${ 3. }
` ( “$a+$b” , ( { A. , B , 预期 } ) => {
测验 ( ` 返回 ${ 预期 } ` , ( ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ;
} ) ;
测验 ( ` 返回值不能大于 ${ 预期 } ` , ( ) => {
预料 ( A. + B ) . . ( 预期 ) ;
} ) ;
测验 ( ` 返回值不能小于 ${ 预期 } ` , ( ) => {
预料 ( A. + B ) . . 托布利森 ( 预期 ) ;
} ) ;
} ) ;

仅描述(名称,fn)#

也在别名下:F描述(姓名,fn)

你可以用仅描述如果只想运行一个描述块:

描述 . 只有 ( “我的饮料” , ( ) => {
测验 ( “很好吃” , ( ) => {
预料 ( 我的饮料 . 美味的 ) . 托贝特鲁西 ( ) ;
} ) ;
测验 ( “不是酸的” , ( ) => {
预料 ( 我的饮料 . 酸的 ) . 托贝尔西 ( ) ;
} ) ;
} ) ;
描述 ( “我的另一种饮料” , ( ) => {
// ... 将被跳过
} ) ;

仅描述每个(表)(名称,fn)#

也在别名下:F每个(表)的描述(名称,fn)fdescribe.each`table`(名称,fn)

使用只描述每一个如果您只想运行特定的测试,请选择数据驱动测试套件。

只描述每一个提供了两个API:

仅描述每个(表)(名称,fn)#

描述 . 只有 . 每个 ( [
[ 1. , 1. , 2. ] ,
[ 1. , 2. , 3. ] ,
[ 2. , 1. , 3. ] ,
] ) ( “.添加(%i,%i)” , ( A. , B , 预期 ) => {
测验 ( ` 返回 ${ 预期 } ` , ( ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ;
} ) ;
} ) ;
测验 ( “将不会运行” , ( ) => {
预料 ( 1. / 0 ) . 托比 ( 无穷 ) ;
} ) ;

仅描述.每个“表”(名称,fn)#

描述 . 只有 . 每个 `
a | b |预期
${ 1. } | ${ 1. } | ${ 2. }
${ 1. } | ${ 2. } | ${ 3. }
${ 2. } | ${ 1. } | ${ 3. }
` ( '在添加$a时返回预期的$b' , ( { A. , B , 预期 } ) => {
测验 ( “通行证” , ( ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ;
} ) ;
} ) ;
测验 ( “将不会运行” , ( ) => {
预料 ( 1. / 0 ) . 托比 ( 无穷 ) ;
} ) ;

description.skip(名称,fn)#

也在别名下:xdescripe(名称,fn)

你可以用描述。跳过如果不想运行特定的描述块:

描述 ( “我的饮料” , ( ) => {
测验 ( “很好吃” , ( ) => {
预料 ( 我的饮料 . 美味的 ) . 托贝特鲁西 ( ) ;
} ) ;
测验 ( “不是酸的” , ( ) => {
预料 ( 我的饮料 . 酸的 ) . 托贝尔西 ( ) ;
} ) ;
} ) ;
描述 . 跳过 ( “我的另一种饮料” , ( ) => {
// ... 将被跳过
} ) ;

使用描述。跳过通常是临时注释掉一大块测试的更干净的替代方法。

描述.跳过.每个(表)(名称,fn)#

也在别名下:xdescripe.每个(表)(名称,fn)xdescripe.each`table`(名称,fn)

使用描述每一个如果您想停止运行一套数据驱动测试。

描述每一个提供了两个API:

描述.跳过.每个(表)(名称,fn)#

描述 . 跳过 . 每个 ( [
[ 1. , 1. , 2. ] ,
[ 1. , 2. , 3. ] ,
[ 2. , 1. , 3. ] ,
] ) ( “.添加(%i,%i)” , ( A. , B , 预期 ) => {
测验 ( ` 返回 ${ 预期 } ` , ( ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ; //将不会运行
} ) ;
} ) ;
测验 ( “将被运行” , ( ) => {
预料 ( 1. / 0 ) . 托比 ( 无穷 ) ;
} ) ;

description.skip.each`table`(名称,fn)#

描述 . 跳过 . 每个 `
a | b |预期
${ 1. } | ${ 1. } | ${ 2. }
${ 1. } | ${ 2. } | ${ 3. }
${ 2. } | ${ 1. } | ${ 3. }
` ( '在添加$a时返回预期的$b' , ( { A. , B , 预期 } ) => {
测验 ( “将不会运行” , ( ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ; //将不会运行
} ) ;
} ) ;
测验 ( “将被运行” , ( ) => {
预料 ( 1. / 0 ) . 托比 ( 无穷 ) ;
} ) ;

测试(名称、fn、超时)#

也在别名下:it(名称、fn、超时)

测试文件中所需的只是测验运行测试的方法。例如,假设有一个函数inchesOfRain()应该是零。你的整个测试可以是:

测验 ( “没有下雨” , ( ) => {
预料 ( 微乎其微 ( ) ) . 托比 ( 0 ) ;
} ) ;

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

注:如果承诺得到回报从…起测验,Jest将等待承诺解决后再让测试完成。如果为测试函数提供一个参数,通常称为完成. 当您想要测试回调时,这可能很方便。请参见如何测试异步代码在这里.

比如说获取原始列表()返回一个承诺,该承诺应解析为具有柠檬在里面。您可以使用以下方法对此进行测试:

测验 ( “里面有柠檬” , ( ) => {
回来 拉格利斯特 ( ) . 然后 ( 列表 => {
预料 ( 列表 ) . 控制 ( “柠檬” ) ;
} ) ;
} ) ;

即使打电话给测验将立即返回,直到承诺也解决,测试才完成。

test.concurrent(名称、fn、超时)#

也在别名下:it.concurrent(名称、fn、超时)

使用test.concurrent如果希望测试同时运行。

注:test.concurrent被认为是实验性的-参见在这里有关缺少的功能和其他问题的详细信息

第一个参数是测试名称;第二个参数是异步函数,其中包含要测试的期望值。第三个参数(可选)是超时(以毫秒为单位)用于指定中止前的等待时间。注意:默认超时为5秒。

test.concurrent('添加2个数字',异步()=>{
期望(5+3),期望(8);
});
test.concurrent('减法2个数字',异步()=>{
期望(5-3),期望(2);
});

注:使用最大并发在配置中,防止Jest同时执行超过指定数量的测试

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

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

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

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

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

  • 桌子:大堆包含传递到测试中的参数的数组的fn每行。
    • 笔记如果传入一个1D基元数组,它将在内部映射到一个表,即。[1, 2, 3] -> [[1], [2], [3]]
  • 名称:一串试块的标题。
    • 通过使用位置注入参数生成唯一的测试标题printf格式化:
      • %p-漂亮的格式.
      • %-绳子。
      • %d-号码。
      • %我-整数。
      • %f-浮点值。
      • %j-JSON。
      • %o-反对。
      • %#-测试用例的索引。
      • %%-单百分号(“%”)。这不会消耗参数。
  • fn:作用要运行的测试,这是将每行中的参数作为函数参数接收的函数,这必须是一个异步函数.
  • 或者,您可以提供超时(以毫秒为单位)用于指定在中止前等待每行的时间。注意:默认超时为5秒。

例子:

测验 . 同时发生的 . 每个 ( [
[ 1. , 1. , 2. ] ,
[ 1. , 2. , 3. ] ,
[ 2. , 1. , 3. ] ,
] ) ( “.添加(%i,%i)” , 异步的 ( A. , B , 预期 ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ;
} ) ;

2.test.concurrent.each`table`(名称、fn、超时)#

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

例子:

测验 . 同时发生的 . 每个 `
a | b |预期
${ 1. } | ${ 1. } | ${ 2. }
${ 1. } | ${ 2. } | ${ 3. }
${ 2. } | ${ 1. } | ${ 3. }
` ( '在添加$a时返回预期的$b' , 异步的 ( { A. , B , 预期 } ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ;
} ) ;

test.concurrent.only.each(表)(名称,fn)#

也在别名下:it.concurrent.only.each(表)(名称,fn)

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

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

test.concurrent.only.each(表)(名称,fn)#

测验 . 同时发生的 . 只有 . 每个 ( [
[ 1. , 1. , 2. ] ,
[ 1. , 2. , 3. ] ,
[ 2. , 1. , 3. ] ,
] ) ( “.添加(%i,%i)” , 异步的 ( A. , B , 预期 ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ;
} ) ;
测验 ( “将不会运行” , ( ) => {
预料 ( 1. / 0 ) . 托比 ( 无穷 ) ;
} ) ;

仅测试。每个“表”(名称,fn)#

测验 . 同时发生的 . 只有 . 每个 `
a | b |预期
${ 1. } | ${ 1. } | ${ 2. }
${ 1. } | ${ 2. } | ${ 3. }
${ 2. } | ${ 1. } | ${ 3. }
` ( '在添加$a时返回预期的$b' , 异步的 ( { A. , B , 预期 } ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ;
} ) ;
测验 ( “将不会运行” , ( ) => {
预料 ( 1. / 0 ) . 托比 ( 无穷 ) ;
} ) ;

test.concurrent.skip.each(表)(名称,fn)#

也在别名下:it.concurrent.skip.each(表)(名称,fn)

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

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

test.concurrent.skip.each(表)(名称,fn)#

测验 . 同时发生的 . 跳过 . 每个 ( [
[ 1. , 1. , 2. ] ,
[ 1. , 2. , 3. ] ,
[ 2. , 1. , 3. ] ,
] ) ( “.添加(%i,%i)” , 异步的 ( A. , B , 预期 ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ; //将不会运行
} ) ;
测验 ( “将被运行” , ( ) => {
预料 ( 1. / 0 ) . 托比 ( 无穷 ) ;
} ) ;

test.concurrent.skip.each`table`(名称,fn)#

测验 . 同时发生的 . 跳过 . 每个 `
a | b |预期
${ 1. } | ${ 1. } | ${ 2. }
${ 1. } | ${ 2. } | ${ 3. }
${ 2. } | ${ 1. } | ${ 3. }
` ( '在添加$a时返回预期的$b' , 异步的 ( { A. , B , 预期 } ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ; //将不会运行
} ) ;
测验 ( “将被运行” , ( ) => {
预料 ( 1. / 0 ) . 托比 ( 无穷 ) ;
} ) ;

每个测试(表)(名称、fn、超时)#

也在别名下:it.每个(表)(名称,fn)每个“表”(名称,fn)

使用测试每个如果你用不同的数据重复相同的测试。测试每个允许您编写一次测试并传入数据。

测试每个提供了两个API:

1.每个测试(表)(名称、fn、超时)#

  • 桌子:大堆包含传递到测试中的参数的数组的fn每行。
    • 笔记如果传入一个1D基元数组,它将在内部映射到一个表,即。[1, 2, 3] -> [[1], [2], [3]]
  • 名称:一串试块的标题。
    • 通过使用位置注入参数生成唯一的测试标题printf格式化:
      • %p-漂亮的格式.
      • %-绳子。
      • %d-号码。
      • %我-整数。
      • %f-浮点值。
      • %j-JSON。
      • %o-反对。
      • %#-测试用例的索引。
      • %%-单百分号(“%”)。这不会消耗参数。
    • 或者通过将测试用例对象的属性注入$variable
      • 要使用注入嵌套对象值,可以提供键路径,即。$variable.path.to.value
      • 你可以用$#注入测试用例的索引
      • 你不能使用$variableprintf%%
  • fn:作用要运行的测试,这是将每行中的参数作为函数参数接收的函数。
  • 或者,您可以提供超时(以毫秒为单位)用于指定在中止前等待每行的时间。注意:默认超时为5秒。

例子:

测验 . 每个 ( [
[ 1. , 1. , 2. ] ,
[ 1. , 2. , 3. ] ,
[ 2. , 1. , 3. ] ,
] ) ( “.添加(%i,%i)” , ( A. , B , 预期 ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ;
} ) ;
测验 . 每个 ( [
{ A. : 1. , B : 1. , 预期 : 2. } ,
{ A. : 1. , B : 2. , 预期 : 3. } ,
{ A. : 2. , B : 1. , 预期 : 3. } ,
] ) ( “.加上($a,$b)” , ( { A. , B , 预期 } ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ;
} ) ;

2.test.each`table`(名称、fn、超时)#

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

例子:

测验 . 每个 `
a | b |预期
${ 1. } | ${ 1. } | ${ 2. }
${ 1. } | ${ 2. } | ${ 3. }
${ 2. } | ${ 1. } | ${ 3. }
` ( '在添加$a时返回预期的$b' , ( { A. , B , 预期 } ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ;
} ) ;

仅测试(名称、fn、超时)#

也在别名下:仅限(名称、fn、超时)拟合(名称、fn、超时)

调试大型测试文件时,通常只希望运行测试的子集。你可以用只有指定要在该测试文件中运行的测试。

或者,您可以提供超时(以毫秒为单位)用于指定中止前的等待时间。注意:默认超时为5秒。

例如,假设您进行了以下测试:

测验 . 只有 ( “下雨了” , ( ) => {
预料 ( 微乎其微 ( ) ) . ( 0 ) ;
} ) ;
测验 ( “没有下雪” , ( ) => {
预料 ( 英希索夫斯诺 ( ) ) . 托比 ( 0 ) ;
} ) ;

只有“it is raining”测试将在该测试文件中运行,因为它是使用仅测试.

通常,您不会使用仅测试进入源代码管理-您可以使用它进行调试,并在修复了损坏的测试后将其删除。

仅测试每个(表)(名称,fn)#

也在别名下:仅限it.每个(表)(名称,fn),每个(表)(名称,fn),仅限。每个“表”(名称,fn)fit.每个“表”(名称,fn)

使用只测试每个如果只希望使用不同的测试数据运行特定测试。

只测试每个提供了两个API:

仅测试每个(表)(名称,fn)#

测验 . 只有 . 每个 ( [
[ 1. , 1. , 2. ] ,
[ 1. , 2. , 3. ] ,
[ 2. , 1. , 3. ] ,
] ) ( “.添加(%i,%i)” , ( A. , B , 预期 ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ;
} ) ;
测验 ( “将不会运行” , ( ) => {
预料 ( 1. / 0 ) . 托比 ( 无穷 ) ;
} ) ;

仅测试。每个“表”(名称,fn)#

测验 . 只有 . 每个 `
a | b |预期
${ 1. } | ${ 1. } | ${ 2. }
${ 1. } | ${ 2. } | ${ 3. }
${ 2. } | ${ 1. } | ${ 3. }
` ( '在添加$a时返回预期的$b' , ( { A. , B , 预期 } ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ;
} ) ;
测验 ( “将不会运行” , ( ) => {
预料 ( 1. / 0 ) . 托比 ( 无穷 ) ;
} ) ;

test.skip(名称,fn)#

也在别名下:it.skip(名称,fn),xit(姓名,fn)xtest(名称,fn)

维护大型代码库时,有时可能会发现某个测试因某种原因暂时中断。如果要跳过运行此测试,但不想删除此代码,可以使用测试跳过指定要跳过的某些测试。

例如,假设您进行了以下测试:

测验 ( “下雨了” , ( ) => {
预料 ( 微乎其微 ( ) ) . ( 0 ) ;
} ) ;
测验 . 跳过 ( “没有下雪” , ( ) => {
预料 ( 英希索夫斯诺 ( ) ) . 托比 ( 0 ) ;
} ) ;

只有“it is raining”测试将运行,因为另一个测试是使用测试跳过.

您可以对测试进行注释,但使用它通常会更好一些测试跳过因为它将保持缩进和语法突出显示。

测试.跳过.每个(表)(名称,fn)#

也在别名下:it.skip.each(表)(名称,fn),xit.每个(表)(名称,fn),xtest.每个(表)(名称,fn),it.skip.each`table`(名称,fn),xit.每个“表”(名称,fn)xtest.each`table`(名称,fn)

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

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

测试.跳过.每个(表)(名称,fn)#

测验 . 跳过 . 每个 ( [
[ 1. , 1. , 2. ] ,
[ 1. , 2. , 3. ] ,
[ 2. , 1. , 3. ] ,
] ) ( “.添加(%i,%i)” , ( A. , B , 预期 ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ; //将不会运行
} ) ;
测验 ( “将被运行” , ( ) => {
预料 ( 1. / 0 ) . 托比 ( 无穷 ) ;
} ) ;

test.skip.each`table`(名称,fn)#

测验 . 跳过 . 每个 `
a | b |预期
${ 1. } | ${ 1. } | ${ 2. }
${ 1. } | ${ 2. } | ${ 3. }
${ 2. } | ${ 1. } | ${ 3. }
` ( '在添加$a时返回预期的$b' , ( { A. , B , 预期 } ) => {
预料 ( A. + B ) . 托比 ( 预期 ) ; //将不会运行
} ) ;
测验 ( “将被运行” , ( ) => {
预料 ( 1. / 0 ) . 托比 ( 无穷 ) ;
} ) ;

test.todo(名称)#

也在别名下:it.todo(名称)

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

笔记:如果提供测试回调函数,则test.todo将引发错误。如果您已经实现了测试,但它已被破坏,并且不希望它运行,则使用测试跳过相反

美国石油学会#

  • 名称:一串测试计划的标题。

例子:

常数 添加 = ( A. , B ) => A. + B ;
测验 . 待办事项 ( “添加应该是关联的” ) ;
最近更新日期通过西门·贝克胡斯