跳到主要内容
版本:25.倍

全局

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

方法#


参考#

追随(FN,超时)#

在此文件中的所有测试完成后运行函数。如果函数返回承诺或是生成器,则Jest等待该承诺在继续之前解析。

可选地,您可以提供一个超时(以毫秒为单位),用于指定在中止前等待多长时间。注意:默认超时为5秒。

如果要清理测试的某些全局设置状态,这通常是有用的。

例如:

const GlobalDatabase. = makeGlobalDatabase ( ) ;
功能 cleanUpDatabase ( db ) {
db 清理 ( ) ;
}
毕竟 ( ( ) = > {
cleanUpDatabase ( GlobalDatabase. ) ;
} ) ;
测试 ( '可以找到东西' , ( ) = > {
返回 GlobalDatabase. ( “东西” , { } , 结果 = > {
预计 ( 结果 长度 ) tobegreathan ( 0 ) ;
} ) ;
} ) ;
测试 ( “可以插入一个东西” , ( ) = > {
返回 GlobalDatabase. 插入 ( “东西” , makething. ( ) , 响应 = > {
预计 ( 响应 成功 ) Tobeththy. ( ) ;
} ) ;
} ) ;

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

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

如果您想在每次测试之后运行一些清理而不是在所有测试之后,请使用afterEach代替。

追随者(FN,超时)#

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

可选地,您可以提供一个超时(以毫秒为单位),用于指定在中止前等待多长时间。注意:默认超时为5秒。

如果要清理每个测试创建的某些临时状态,这通常是有用的。

例如:

const GlobalDatabase. = makeGlobalDatabase ( ) ;
功能 cleanUpDatabase ( db ) {
db 清理 ( ) ;
}
afterEach ( ( ) = > {
cleanUpDatabase ( GlobalDatabase. ) ;
} ) ;
测试 ( '可以找到东西' , ( ) = > {
返回 GlobalDatabase. ( “东西” , { } , 结果 = > {
预计 ( 结果 长度 ) tobegreathan ( 0 ) ;
} ) ;
} ) ;
测试 ( “可以插入一个东西” , ( ) = > {
返回 GlobalDatabase. 插入 ( “东西” , makething. ( ) , 响应 = > {
预计 ( 响应 成功 ) Tobeththy. ( ) ;
} ) ;
} ) ;

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

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

如果您想仅在一次运行一些清理,请运行所有测试,使用毕竟代替。

Beforeall(FN,超时)#

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

可选地,您可以提供一个超时(以毫秒为单位),用于指定在中止前等待多长时间。注意:默认超时为5秒。

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

例如:

const GlobalDatabase. = makeGlobalDatabase ( ) ;
beforeAll ( ( ) = > {
//清除数据库并添加一些测试数据。
// Jest将在运行测试之前等待此承诺解决。
返回 GlobalDatabase. 清晰的 ( ) 然后 ( ( ) = > {
返回 GlobalDatabase. 插入 ( { testData : 'foo' } ) ;
} ) ;
} ) ;
//因为在这个例子中我们只设置了一次数据库,所以它很重要
//我们的测试不会修改它。
测试 ( '可以找到东西' , ( ) = > {
返回 GlobalDatabase. ( “东西” , { } , 结果 = > {
预计 ( 结果 长度 ) tobegreathan ( 0 ) ;
} ) ;
} ) ;

在这里beforeAll确保在测试运行之前设置好数据库。如果安装是同步的,那么您可以不使用beforeAll。关键是jest将等待承诺要解决,因此您也可以具有异步设置。

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

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

前言(FN,超时)#

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

可选地,您可以提供一个超时(以毫秒为单位),用于指定在中止前等待多长时间。注意:默认超时为5秒。

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

例如:

const GlobalDatabase. = makeGlobalDatabase ( ) ;
beforeEach ( ( ) = > {
//清除数据库并添加一些测试数据。
// Jest将在运行测试之前等待此承诺解决。
返回 GlobalDatabase. 清晰的 ( ) 然后 ( ( ) = > {
返回 GlobalDatabase. 插入 ( { testData : 'foo' } ) ;
} ) ;
} ) ;
测试 ( '可以找到东西' , ( ) = > {
返回 GlobalDatabase. ( “东西” , { } , 结果 = > {
预计 ( 结果 长度 ) tobegreathan ( 0 ) ;
} ) ;
} ) ;
测试 ( “可以插入一个东西” , ( ) = > {
返回 GlobalDatabase. 插入 ( “东西” , makething. ( ) , 响应 = > {
预计 ( 响应 成功 ) Tobeththy. ( ) ;
} ) ;
} ) ;

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

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

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

描述(名称,fn)#

描述(名称,fn)创建一个块,将多个相关测试组合在一起。例如,如果你有一个myBeverage应该是美味但不是酸的对象,你可以用:

const myBeverage = {
可口的 : 真的 ,
酸的 : ,
} ;
描述 ( '我的饮料' , ( ) = > {
测试 ( '美味' , ( ) = > {
预计 ( myBeverage 可口的 ) Tobeththy. ( ) ;
} ) ;
测试 ( “不是酸” , ( ) = > {
预计 ( myBeverage 酸的 ) 吐痰 ( ) ;
} ) ;
} ) ;

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

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

const binaryStringToNumber = binstring. = > {
如果 ( ! / ^ [01] + $ / 测试 ( binstring. ) ) {
新的 CustomError ( '不是二进制数。' ) ;
}
返回 释放 ( binstring. , 2 ) ;
} ;
描述 ( 'biniarstringtonumber' , ( ) = > {
描述 ( '给定一个无效的二进制字符串' , ( ) = > {
测试 ( '由非数字抛出CustomError'组成 , ( ) = > {
预计 ( ( ) = > binaryStringToNumber ( 'abc' ) ) Totholowerror ( CustomError ) ;
} ) ;
测试 ( '用额外的空白抛出CustomError' , ( ) = > {
预计 ( ( ) = > binaryStringToNumber ( “100” ) ) Totholowerror ( CustomError ) ;
} ) ;
} ) ;
描述 ( '给定一个有效的二进制字符串' , ( ) = > {
测试 ( '返回正确的数字' , ( ) = > {
预计 ( binaryStringToNumber ( '100' ) ) 托比 ( 4 ) ;
} ) ;
} ) ;
} ) ;

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

使用描述如果您继续使用不同的数据复制相同的测试套件。描述允许您编写测试套件并将数据传递进来。

描述有两个API:

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

  • 表格:大批与传递到的参数的阵列fn为每一行。
    • 请注意如果您通过1D数组的基元,则内部将映射到表I.E.[1,2,3] - > [[1],[2],[3]]
  • 名称:字符串测试套件的标题。
    • 通过位置注入参数来生成唯一的测试标题Printf.格式化:
      • % p-漂亮格式
      • % s- 细绳。
      • % d——数字。
      • %我- 整数。
      • % f—浮点值。
      • % j- json。
      • %啊——对象。
      • % #-测试用例索引。
      • % %- 单百分号('%')。这不会消耗参数。
  • fn:功能要耗尽的测试套件,这是将在每个行中接收参数的函数参数。
  • 可选地,您可以提供一个超时(以毫秒为单位),指定在中止前每一行等待多长时间。注意:默认超时为5秒。

例子:

描述 每个 ( (
( 1 , 1 , 2 ] ,
( 1 , 2 , 3. ] ,
( 2 , 1 , 3. ] ,
] ) ( '.dd(%i,%i)' , ( 一个 , b , 预期的 ) = > {
测试 ( 返回 $ { 预期的 } , ( ) = > {
预计 ( 一个 + b ) 托比 ( 预期的 ) ;
} ) ;
测试 ( 返回值不大于 $ { 预期的 } , ( ) = > {
预计 ( 一个 + b ) 不是 tobegreathan ( 预期的 ) ;
} ) ;
测试 ( 返回的值不小于 $ { 预期的 } , ( ) = > {
预计 ( 一个 + b ) 不是 toBeLessThan ( 预期的 ) ;
} ) ;
} ) ;

2。Devely.evelable`(姓名,fn,超时)#

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

例子:

描述 每个
a |B |预期的
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
( “a + b美元” , ( { 一个 , b , 预期的 } ) = > {
测试 ( 返回 $ { 预期的 } , ( ) = > {
预计 ( 一个 + b ) 托比 ( 预期的 ) ;
} ) ;
测试 ( 返回值不大于 $ { 预期的 } , ( ) = > {
预计 ( 一个 + b ) 不是 tobegreathan ( 预期的 ) ;
} ) ;
测试 ( 返回的值不小于 $ { 预期的 } , ( ) = > {
预计 ( 一个 + b ) 不是 toBeLessThan ( 预期的 ) ;
} ) ;
} ) ;

describe.only(名称,fn)#

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

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

描述 只要 ( '我的饮料' , ( ) = > {
测试 ( '美味' , ( ) = > {
预计 ( myBeverage 可口的 ) Tobeththy. ( ) ;
} ) ;
测试 ( “不是酸” , ( ) = > {
预计 ( myBeverage 酸的 ) 吐痰 ( ) ;
} ) ;
} ) ;
描述 ( “我的其他饮料” , ( ) = > {
/ /……将被忽略
} ) ;

sefy.only.each(表)(姓名,fn)#

也在别名下:fdescribe.each(表)(姓名,fn)fdescribe.each``(姓名,fn)

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

sefy.only.each.有两个API:

sefy.only.each(表)(姓名,fn)#

描述 只要 每个 ( (
( 1 , 1 , 2 ] ,
( 1 , 2 , 3. ] ,
( 2 , 1 , 3. ] ,
] ) ( '.dd(%i,%i)' , ( 一个 , b , 预期的 ) = > {
测试 ( 返回 $ { 预期的 } , ( ) = > {
预计 ( 一个 + b ) 托比 ( 预期的 ) ;
} ) ;
} ) ;
测试 ( '不会被跑' , ( ) = > {
预计 ( 1 / 0 ) 托比 ( ) ;
} ) ;

sefy.only.each.”表格”(名称,fn)#

描述 只要 每个
a |B |预期的
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
( '返回$ a预期$ a增加$ b' , ( { 一个 , b , 预期的 } ) = > {
测试 ( '通过' , ( ) = > {
预计 ( 一个 + b ) 托比 ( 预期的 ) ;
} ) ;
} ) ;
测试 ( '不会被跑' , ( ) = > {
预计 ( 1 / 0 ) 托比 ( ) ;
} ) ;

陈述(名称,fn)#

也在别名下:xdescribe(名称、fn)

您可以使用陈述如果您不想运行特定描述块:

描述 ( '我的饮料' , ( ) = > {
测试 ( '美味' , ( ) = > {
预计 ( myBeverage 可口的 ) Tobeththy. ( ) ;
} ) ;
测试 ( “不是酸” , ( ) = > {
预计 ( myBeverage 酸的 ) 吐痰 ( ) ;
} ) ;
} ) ;
描述 跳过 ( “我的其他饮料” , ( ) = > {
/ /……将被忽略
} ) ;

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

describe.skip.each(表)(姓名,fn)#

也在别名下:xdescribe.each(表)(姓名,fn)xdescribe。每个”表格”(名称,fn)

使用describe.skip.each.如果要停止运行套件数据驱动测试。

describe.skip.each.有两个API:

describe.skip.each(表)(姓名,fn)#

描述 跳过 每个 ( (
( 1 , 1 , 2 ] ,
( 1 , 2 , 3. ] ,
( 2 , 1 , 3. ] ,
] ) ( '.dd(%i,%i)' , ( 一个 , b , 预期的 ) = > {
测试 ( 返回 $ { 预期的 } , ( ) = > {
预计 ( 一个 + b ) 托比 ( 预期的 ) ; //不会被运行
} ) ;
} ) ;
测试 ( 会跑的 , ( ) = > {
预计 ( 1 / 0 ) 托比 ( ) ;
} ) ;

describe.skip.each``(姓名,fn)#

描述 跳过 每个
a |B |预期的
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
( '返回$ a预期$ a增加$ b' , ( { 一个 , b , 预期的 } ) = > {
测试 ( '不会被跑' , ( ) = > {
预计 ( 一个 + b ) 托比 ( 预期的 ) ; //不会被运行
} ) ;
} ) ;
测试 ( 会跑的 , ( ) = > {
预计 ( 1 / 0 ) 托比 ( ) ;
} ) ;

测试(名称、fn超时)#

也在别名下:它(姓名,fn,超时)

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

测试 ( 没有下雨的 , ( ) = > {
预计 ( inchesOfRain ( ) ) 托比 ( 0 ) ;
} ) ;

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

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

例如,让我们说fetchBeverageList ()返回一个应该解析为具有的列表的承诺柠檬在里面。你可以用:

测试 ( '有柠檬' , ( ) = > {
返回 fetchBeverageList ( ) 然后 ( 列表 = > {
预计 ( 列表 ) toContain ( '柠檬' ) ;
} ) ;
} ) ;

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

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

也在别名下:一般(表)(名称、fn)它。住方式(名字,fn)

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

test.each.有两个API:

1。test.each(表)(名称,fn,超时)#

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

例子:

测试 每个 ( (
( 1 , 1 , 2 ] ,
( 1 , 2 , 3. ] ,
( 2 , 1 , 3. ] ,
] ) ( '.dd(%i,%i)' , ( 一个 , b , 预期的 ) = > {
预计 ( 一个 + b ) 托比 ( 预期的 ) ;
} ) ;

2。test.each`(姓名,fn,超时)#

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

例子:

测试 每个
a |B |预期的
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
( '返回$ a预期$ a增加$ b' , ( { 一个 , b , 预期的 } ) = > {
预计 ( 一个 + b ) 托比 ( 预期的 ) ;
} ) ;

test.only.(名称,fn,超时)#

也在别名下:它。(名称,fn,超时), 和fit(名称、fn超时)

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

可选地,您可以提供一个超时(以毫秒为单位),用于指定在中止前等待多长时间。注意:默认超时为5秒。

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

测试 只要 ( “下雨了” , ( ) = > {
预计 ( inchesOfRain ( ) ) tobegreathan ( 0 ) ;
} ) ;
测试 ( '它没有下雪' , ( ) = > {
预计 ( inchesofsnow. ( ) ) 托比 ( 0 ) ;
} ) ;

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

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

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

也在别名下:it.only.each(表)(姓名,fn),fit.each(表)(名称、fn),it.Only.Each`(姓名,fn)fit.each``(名字,fn)

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

test.only.each.有两个API:

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

测试 只要 每个 ( (
( 1 , 1 , 2 ] ,
( 1 , 2 , 3. ] ,
( 2 , 1 , 3. ] ,
] ) ( '.dd(%i,%i)' , ( 一个 , b , 预期的 ) = > {
预计 ( 一个 + b ) 托比 ( 预期的 ) ;
} ) ;
测试 ( '不会被跑' , ( ) = > {
预计 ( 1 / 0 ) 托比 ( ) ;
} ) ;

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

测试 只要 每个
a |B |预期的
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
( '返回$ a预期$ a增加$ b' , ( { 一个 , b , 预期的 } ) = > {
预计 ( 一个 + b ) 托比 ( 预期的 ) ;
} ) ;
测试 ( '不会被跑' , ( ) = > {
预计 ( 1 / 0 ) 托比 ( ) ;
} ) ;

test.skip(名称,fn)#

也在别名下:它。跳过(名称、fn),xit(名称,fn), 和xtest(名称、fn)

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

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

测试 ( “下雨了” , ( ) = > {
预计 ( inchesOfRain ( ) ) tobegreathan ( 0 ) ;
} ) ;
测试 跳过 ( '它没有下雪' , ( ) = > {
预计 ( inchesofsnow. ( ) ) 托比 ( 0 ) ;
} ) ;

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

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

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

也在别名下:it.skip.each(表)(名称、fn),xit.each(表)(名称、fn),xtest.each(表)(名称、fn),it.skip。每个”表格”(名称,fn),——xit。每个”表格”(名称,fn)xtest.each``(姓名,fn)

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

test.skip.each.有两个API:

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

测试 跳过 每个 ( (
( 1 , 1 , 2 ] ,
( 1 , 2 , 3. ] ,
( 2 , 1 , 3. ] ,
] ) ( '.dd(%i,%i)' , ( 一个 , b , 预期的 ) = > {
预计 ( 一个 + b ) 托比 ( 预期的 ) ; //不会被运行
} ) ;
测试 ( 会跑的 , ( ) = > {
预计 ( 1 / 0 ) 托比 ( ) ;
} ) ;

test.skip.each``(姓名,fn)#

测试 跳过 每个
a |B |预期的
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
( '返回$ a预期$ a增加$ b' , ( { 一个 , b , 预期的 } ) = > {
预计 ( 一个 + b ) 托比 ( 预期的 ) ; //不会被运行
} ) ;
测试 ( 会跑的 , ( ) = > {
预计 ( 1 / 0 ) 托比 ( ) ;
} ) ;

test.todo(姓名)#

也在别名下:它.Todo(姓名)

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

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

API.#

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

例子:

const 添加 = ( 一个 , b ) = > 一个 + b ;
测试 待办事项 ( “add应该是联想的” ) ;
上次更新了通过SébastienLorber.