跳转到主要内容
版本:26.倍

Глобальніметоди.

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

Методи#


参考#

毕竟(fn,超时)#

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

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

Наприклад:

Наприклад:

常量 globalDatabase = makeGlobalDatabase ( ) ;
函数 cleanUpDatabase ( db ) {
db 清理 ( ) ;
}
毕竟 ( ( ) => {
cleanUpDatabase ( globalDatabase ) ;
} ) ;
测试 ( '可以找到东西' , ( ) => {
返回 globalDatabase 找到 ( “东西” , { } , 结果 => {
预计 ( 结果 长度 ) toBeGreaterThan ( 0 ) ;
} ) ;
} ) ;
测试 ( “可以插入一个东西” , ( ) => {
返回 globalDatabase 插入 ( “东西” , 使 ( ) , 回复 => {
预计 ( 回复 成功 ) toBeTruthy ( ) ;
} ) ;
} ) ;

Якщо毕竟знаходитьсявсерединіблоку描述, він виконується в кінці цього блоку тестів。

Якщовихочетевиконуватиочисткупіслякожноготесту,використовуйтеafterEachвзамін。

Якщовихочетевиконуватиочисткупіслякожноготесту,використовуйтеafterEachвзамін。

afterEach (fn,超时)#

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

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

Наприклад:

Наприклад:

常量 globalDatabase = makeGlobalDatabase ( ) ;
函数 cleanUpDatabase ( db ) {
db 清理 ( ) ;
}
afterEach ( ( ) => {
cleanUpDatabase ( globalDatabase ) ;
} ) ;
测试 ( '可以找到东西' , ( ) => {
返回 globalDatabase 找到 ( “东西” , { } , 结果 => {
预计 ( 结果 长度 ) toBeGreaterThan ( 0 ) ;
} ) ;
} ) ;
测试 ( “可以插入一个东西” , ( ) => {
返回 globalDatabase 插入 ( “东西” , 使 ( ) , 回复 => {
预计 ( 回复 成功 ) toBeTruthy ( ) ;
} ) ;
} ) ;

ЯкщоafterEachзнаходитьсявсерединіблоку描述,ВінВиконуштьсяЛишепіслякожноготестувсерединіцьогоблоку。

Якщовихочетевиконуватипевнуочисткутількиодинразпіслявиконаннявсіхтестів,використовуйте毕竟

Якщовихочетевиконуватипевнуочисткутількиодинразпіслявиконаннявсіхтестів,використовуйте毕竟

beforeAll (fn,超时)#

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

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

Наприклад:

Наприклад:

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

ТутbeforeAllГарантую,щобазаданихБудестворена,Перюніжзапускатитести。如果设置是同步的,则可以没有beforeAll。Основнаперевагаполягаєвтому、щоJestчекатиме,покивиконаєтьсяпроміс,щодозволяєвикористанняасинхроннихналаштувань。

кщовиочетевиконуватиякіськомандипередзапускомкожноготесту,ВикористовуйтеbeforeEachвзамін。

кщовиочетевиконуватиякіськомандипередзапускомкожноготесту,ВикористовуйтеbeforeEachвзамін。

beforeEach (fn,超时)#

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

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

Наприклад:

Наприклад:

常量 globalDatabase = makeGlobalDatabase ( ) ;
beforeEach ( ( ) => {
//清除数据库并添加一些测试数据。
// Jest将在运行测试之前等待此承诺解决。
返回 globalDatabase 清除 ( ) 然后 ( ( ) => {
返回 globalDatabase 插入 ( { testData : “foo” } ) ;
} ) ;
} ) ;
测试 ( '可以找到东西' , ( ) => {
返回 globalDatabase 找到 ( “东西” , { } , 结果 => {
预计 ( 结果 长度 ) toBeGreaterThan ( 0 ) ;
} ) ;
} ) ;
测试 ( “可以插入一个东西” , ( ) => {
返回 globalDatabase 插入 ( “东西” , 使 ( ) , 回复 => {
预计 ( 回复 成功 ) toBeTruthy ( ) ;
} ) ;
} ) ;

ЯкщоbeforeEachзнаходитьсявсерединіблоку描述,вінвиконуєтьсяпередкожнимтестомвцьомублоці。

кщовампотрібновиконатиПевніналаштуваннялишеодинРазпередзапускомвсіхтестів,ВикористовуйтеbeforeAllвзамін。

кщовампотрібновиконатиПевніналаштуваннялишеодинРазпередзапускомвсіхтестів,ВикористовуйтеbeforeAllвзамін。

描述(名称,fn)#

描述(名称,fn)创建一个块,将几个相关的测试分组在一起。Наприклад, якщо у вас є об ' єкт保佑який повинен мати властивість美味的і не мати властивості, ви можете протестувати це так:

常量 保佑 = {
美味的 : 真正的 ,
: ,
} ;
描述 ( '我的饮料' , ( ) => {
测试 ( “很好吃” , ( ) => {
预计 ( 保佑 美味的 ) toBeTruthy ( ) ;
} ) ;
测试 ( “不是酸” , ( ) => {
预计 ( 保佑 ) toBeFalsy ( ) ;
} ) ;
} ) ;

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

Ви також можете вкладати блоки描述один в одного якщо у вас є ієрахія тестів:

常量 binaryStringToNumber = binstring. => {
如果 ( ! / ^[01] +美元 / 测试 ( binstring. ) ) {
CustomError ( “不是二进制数字。” ) ;
}
返回 方法用于 ( binstring. , 2 ) ;
} ;
描述 ( “binaryStringToNumber” , ( ) => {
描述 ( '给定一个无效的二进制字符串' , ( ) => {
测试 ( '由非数字抛出CustomError'组成 , ( ) => {
预计 ( ( ) => binaryStringToNumber ( “abc” ) ) toThrowError ( CustomError ) ;
} ) ;
测试 ( '带有额外空格抛出CustomError' , ( ) => {
预计 ( ( ) => binaryStringToNumber ( “100” ) ) toThrowError ( CustomError ) ;
} ) ;
} ) ;
描述 ( '给定一个有效的二进制字符串' , ( ) => {
测试 ( '返回正确的数字' , ( ) => {
预计 ( binaryStringToNumber ( “100” ) ) 托比 ( 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秒。

例子:

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

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

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

例子:

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

describe.only(的名字,fn)#

Виможетевикористовуватиdescribe.only,кщовиочетевиконатилишеодинБлок描述:

Виможетевикористовуватиdescribe.only,кщовиочетевиконатилишеодинБлок描述:

描述 只要 ( '我的饮料' , ( ) => {
测试 ( “很好吃” , ( ) => {
预计 ( 保佑 美味的 ) toBeTruthy ( ) ;
} ) ;
测试 ( “不是酸” , ( ) => {
预计 ( 保佑 ) toBeFalsy ( ) ;
} ) ;
} ) ;
描述 ( “我的其他饮料” , ( ) => {
/ /……将被忽略
} ) ;

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

别名还包括:fdescribe.each(表)(名称、fn)fdescribe。每一个”表格”(的名字,fn)

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

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

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

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

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

描述 只要 每一个
| |预期
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
( 当$a被添加到$b时,返回$expected , ( { 一个 , b , 预期 } ) => {
测试 ( “通过” , ( ) => {
预计 ( 一个 + b ) 托比 ( 预期 ) ;
} ) ;
} ) ;
测试 ( '将不会被运行' , ( ) => {
预计 ( 1 / 0 ) 托比 ( ) ;
} ) ;

describe.skip(的名字,fn)#

Виможетевикористовуватиdescribe.skip,якщовинехочетезапускатитестизпевногоблоку描述:

Виможетевикористовуватиdescribe.skip,якщовинехочетезапускатитестизпевногоблоку描述:

描述 ( '我的饮料' , ( ) => {
测试 ( “很好吃” , ( ) => {
预计 ( 保佑 美味的 ) toBeTruthy ( ) ;
} ) ;
测试 ( “不是酸” , ( ) => {
预计 ( 保佑 ) toBeFalsy ( ) ;
} ) ;
} ) ;
描述 跳过 ( “我的其他饮料” , ( ) => {
/ /……将被忽略
} ) ;

使用describe.skip通常是一个清洁的替代方案,可以暂时评论一大块的测试。

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

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

测试(名称、fn超时)#

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

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

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

Першийаргумент——ценазватесту,другий-функція,якаміститьочікування,якіпотрібноперевірити。第三个参数(可选)是超时(以毫秒为单位)指定在中止之前需要等待多长时间。注意:默认超时时间为5秒。

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

比如说fetchBeverageList ()返回一个承诺,该承诺应该解析到一个具有柠檬在里面。Ви можете протестувати це так:

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

Незважаючинате,що测试відразуповернезначення,тестнебудевиконано,покинебудевиконанопроміс。

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

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

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

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

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

test.concurrent('addition of 2 numbers', async () => {
期望(5 + 3).Tobe(8);
});
test.concurrent('subtraction 2 numbers', async () => {
期望(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秒。

例子:

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

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

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

例子:

测试 并发 每一个
| |预期
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
( 当$a被添加到$b时,返回$expected , ( { 一个 , b , 预期 } ) => {
预计 ( 一个 + 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. ] ,
] ) ( ”。一个dd(%i, %i)' , 异步 ( 一个 , b , 预期 ) => {
预计 ( 一个 + b ) 托比 ( 预期 ) ;
} ) ;
测试 ( '将不会被运行' , ( ) => {
预计 ( 1 / 0 ) 托比 ( ) ;
} ) ;

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

测试 并发 只要 每一个
| |预期
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
( 当$a被添加到$b时,返回$expected , 异步 ( { 一个 , b , 预期 } ) => {
预计 ( 一个 + b ) 托比 ( 预期 ) ;
} ) ;
测试 ( '将不会被运行' , ( ) => {
预计 ( 1 / 0 ) 托比 ( ) ;
} ) ;

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

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

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

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

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

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

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

测试 并发 跳过 每一个
| |预期
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
( 当$a被添加到$b时,返回$expected , 异步 ( { 一个 , b , 预期 } ) => {
预计 ( 一个 + b ) 托比 ( 预期 ) ; //不会被跑
} ) ;
测试 ( 会跑的 , ( ) => {
预计 ( 1 / 0 ) 托比 ( ) ;
} ) ;

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

别名下还有:一般(表)(名称、fn)它。住方式(名字,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秒。

例子:

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

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

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

例子:

测试 每一个
| |预期
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
( 当$a被添加到$b时,返回$expected , ( { 一个 , b , 预期 } ) => {
预计 ( 一个 + b ) 托比 ( 预期 ) ;
} ) ;

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

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

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

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

Наприклад,НехайУВасєнаступніТести:

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

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

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

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

别名还包括:it.only.each(表)(名称、fn),fit.each(表)(姓名,fn),只有。每一个”表格”(的名字,fn)健康。每一个”表格”(的名字,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)#

测试 只要 每一个
| |预期
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
( 当$a被添加到$b时,返回$expected , ( { 一个 , b , 预期 } ) => {
预计 ( 一个 + b ) 托比 ( 预期 ) ;
} ) ;
测试 ( '将不会被运行' , ( ) => {
预计 ( 1 / 0 ) 托比 ( ) ;
} ) ;

test.skip.(的名字,fn)#

别名还包括:it.skip(名称,fn),——xit(名称、fn),xtest(名称,fn)

Коливипідтримуєтевеликукодовубазу、інколиможез”явитися,якийтимчасовозламанийзякихосьпричин。如果您想跳过运行此测试,但又不想删除此代码,您可以使用test.skip.指定一些跳过的测试。

Наприклад,НехайУВасєнаступніТести:

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

Лишетест“下雨了”будевиконано,оскількиіншийтестзапускаєтьсязtest.skip.

您可以评论测试,但通常有点更好test.skip.因为它会维护缩进和语法高亮显示。

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

别名还包括:it.skip.each(表)(名称、fn),xit.each(表)(名称、fn),xtest.each(表)(名称、fn),it.skip。每一个”表格”(的名字,fn),——xit。每一个”表格”(的名字,fn)xtest。每一个”表格”(的名字,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)#

测试 跳过 每一个
| |预期
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
( 当$a被添加到$b时,返回$expected , ( { 一个 , b , 预期 } ) => {
预计 ( 一个 + b ) 托比 ( 预期 ) ; //不会被跑
} ) ;
测试 ( 会跑的 , ( ) => {
预计 ( 1 / 0 ) 托比 ( ) ;
} ) ;

test.todo(名字)#

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

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

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

API#

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

例子:

常量 添加 = ( 一个 , b ) => 一个 + b ;
测试 待办事项 ( “add应该是联想的” ) ;