跳到主要内容
版本:下一步

全球化的人

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

Métodos


参考

Despuésdodo(fn,tiempo)

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

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

Por Ejetrevo:

Por Ejetrevo:

const GlobalDatabase. = makeglobaldatabase. ;
功能 cleanupdatabase. D b {
D b 清理 ;
}
毕竟 => {
cleanupdatabase. GlobalDatabase. ;
} ;
测试 '可以找到东西' => {
返回 GlobalDatabase. '事物' { } 结果 => {
预计 结果 长度 tobegreathan 0. ;
} ;
} ;
测试 '可以插入一件事' => {
返回 GlobalDatabase. '事物' makething. 回复 => {
预计 回复 成功 Tobeththy. ;
} ;
} ;

SI.毕竟Es Llamado Dentro de Un Bloque描述,Este SeEjecutarálalfinal de laejecucióndelbloque dewist。

Si se desea ejecutaralgúntipo de limpieza o restablecimientodescuésde cada prueba en Lugar de al Final de Todas Las Pruebas,Se Puede Utilizarafter

Si se desea ejecutaralgúntipo de limpieza o restablecimientodescuésde cada prueba en Lugar de al Final de Todas Las Pruebas,Se Puede Utilizarafter

追随者(FN,Tiempo)

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

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

Por Ejetrevo:

Por Ejetrevo:

const GlobalDatabase. = makeglobaldatabase. ;
功能 cleanupdatabase. D b {
D b 清理 ;
}
after => {
cleanupdatabase. GlobalDatabase. ;
} ;
测试 '可以找到东西' => {
返回 GlobalDatabase. '事物' { } 结果 => {
预计 结果 长度 tobegreathan 0. ;
} ;
} ;
测试 '可以插入一件事' => {
返回 GlobalDatabase. '事物' makething. 回复 => {
预计 回复 成功 Tobeththy. ;
} ;
} ;

SI.毕竟Es Llamado Dentro de Un Bloque描述,Este SeEjecutaráHARFinal de laEjecucióndeCadaPruebaen El Bloque Describ。

Si se desea ejecutaralgúntipo de limpieza o restablecimieto una sola vez por todas las pruebas,se puede pultizar毕竟

Si se desea ejecutaralgúntipo de limpieza o restablecimieto una sola vez por todas las pruebas,se puede pultizar毕竟

beforeall(fn,tiempo)

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

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

Por Ejetrevo:

Por Ejetrevo:

const GlobalDatabase. = makeglobaldatabase. ;
摘要 => {
//清除数据库并添加一些测试数据。
// Jest将在运行测试之前等待此承诺来解决。
返回 GlobalDatabase. 清除 然后 => {
返回 GlobalDatabase. { 测试数据 'foo' } ;
} ;
} ;
测试 '可以找到东西' => {
返回 GlobalDatabase. '事物' { } 结果 => {
预计 结果 长度 tobegreathan 0. ;
} ;
} ;
测试 '可以插入一件事' => {
返回 GlobalDatabase. '事物' makething. 回复 => {
预计 回复 成功 Tobeththy. ;
} ;
} ;

AquíelbloqueBeforeall.Garantiza Que La Base de Datos Sea Configurada Antes de que se ejecuten las prufebas。如果设置是同步的,则可以没有Beforeall.。La Clave es que eespera一个Una Promise Para Resolver,De Modo QueTambiénSEPEPuede TenerConfiguración无处不闻的asincrona。

Si se desea ejecutarcódigoantes de cada prueba en lugar de tantes de todas las pruebas,se puede Usar摘要

Si se desea ejecutarcódigoantes de cada prueba en lugar de tantes de todas las pruebas,se puede Usar摘要

前言(FN,Tiempo)

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

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

Por Ejetrevo:

Por Ejetrevo:

const GlobalDatabase. = makeglobaldatabase. ;
Beforeall. => {
//清除数据库并添加一些测试数据。
// Jest将在运行测试之前等待此承诺来解决。
返回 GlobalDatabase. 清除 然后 => {
返回 GlobalDatabase. { 测试数据 'foo' } ;
} ;
} ;
//由于我们在此示例中只设置了数据库,因此很重要
//我们的测试不会修改它。测试('可以找到东西',()=> {
返回 GlobalDatabase. '事物' { } 结果 => {
预计 结果 长度 tobegreathan 0. ;
} ;
} ;

Si El BloqueBeforeall.se encuentra dentro de wen bloque描述,Estéseejecutaráfuavezantes de cada prueba en el bloque design。

Si se desea ejecutarcódigodeconfiguración是无数的,Una sola vez antes de Cualquier Prueba,UserséBeforeall.

Si se desea ejecutarcódigodeconfiguración是无数的,Una sola vez antes de Cualquier Prueba,UserséBeforeall.

描述(名称,fn)

描述(名称,fn)创建一个块,将多个相关测试组合在一起。por ejetrevo,si se tiene una objeto保佑que代表una bebida que debe ser deliciosa pero no agria,sepodríaprobar con:

const 保佑 = {
可口的 真的
酸的 错误的
} ;
描述 '我的饮料' => {
测试 '美味' => {
预计 保佑 可口的 Tobeththy. ;
} ;
测试 '不是酸' => {
预计 保佑 酸的 吐痰 ;
} ;
} ;

这不是必需的 - 你可以写下测试直接在顶级块。但如果您更喜欢将测试组织成群组,这可能是方便的。

tambiénse pueden anidar bloques描述SI SE TIENE UNAJERARQUíaDEPRUEBAS:

const Cadenabinariaanumero. = Cadenabinaria. => {
如果 !! / ^ [01] + $ / 测试 Cadenabinaria. {
新的 CustomError. '没有ES UNNúmeroBinario。 ;
}
返回 释放 Cadenabinaria. 2 ;
} ;
描述 'cadenabinariaanumero' => {
描述 'Dada Una Cadena Binaria Invala' => {
测试 'compuesta de no-númerosarroja联合国usicer' => {
预计 => Cadenabinariaanumero. 'abc' Totholowerror. CustomError. ;
} ;
测试 'Con Espacios en Blanco额外的Arroja联合国习惯' => {
预计 => Cadenabinariaanumero. '100' Totholowerror. CustomError. ;
} ;
} ;
描述 'Dada Una Cadena Binaria Valida' => {
测试 'regresa elnúmerofretero' => {
预计 Cadenabinariaanumero. '100' 成为 4. ;
} ;
} ;
} ;

sefyage.each(表)(姓名,fn,超时)

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

描述有两个API:

1。sefyage.each(表)(姓名,fn,超时)

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

例子:

描述 每个 [
[ 1 1 2 ]
[ 1 2 3. ]
[ 2 1 3. ]
] '.dd(%i,%i)' 一种 B. 预期的 => {
测试 ` 回报 $ { 预期的 } ` => {
预计 一种 + B. 成为 预期的 ;
} ;
测试 ` 返回的值不是大于 $ { 预期的 } ` => {
预计 一种 + B. 不是 tobegreathan 预期的 ;
} ;
测试 ` 返回的值不小于 $ { 预期的 } ` => {
预计 一种 + B. 不是 烟幕 预期的 ;
} ;
} ;

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. 不是 烟幕 预期的 ;
} ;
} ;

sefy.only(姓名,fn)

se puede materizar.描述SI SE DESEA EJECUTAR SOLOúnBLOQUE SEWRY:

Si El BloqueBeforeall.se encuentra dentro de wen bloque描述,Estéseejecutaráalprincipio del bloque的描述。

描述 只要 'mi bebida' => {
测试 'ex deliciosa' => {
预计 MIBEBIDA. 熟食店 Tobeththy. ;
} ;
测试 '没有es amarga' => {
预计 MIBEBIDA. amarga. 吐痰 ;
} ;
} ;
描述 'Mi Otra Bebida' => {
// ......将被跳过
} ;

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. 成为 无限 ;
} ;

devely.only.each``(名字,fn)

描述 只要 每个 `
a |B |预期的
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
` '返回$ a预期$ a增加$ b' { 一种 B. 预期的 } => {
测试 '通过' => {
预计 一种 + B. 成为 预期的 ;
} ;
} ;
测试 '不会被跑' => {
预计 1 / 0. 成为 无限 ;
} ;

describe.skip(名称,fn)

se puede materizar.陈述Si SE DESEA OMITIRUN BLOQUE描述了特别的描述:

se puede materizar.陈述Si SE DESEA OMITIRUN BLOQUE描述了特别的描述:

描述 'mi bebida' => {
测试 'ex deliciosa' => {
预计 MIBEBIDA. 熟食店 Tobeththy. ;
} ;
测试 '没有es amarga' => {
预计 MIBEBIDA. amarga. 吐痰 ;
} ;
} ;
描述 跳过 'Mi Otra Bebida' => {
// ......将被跳过
} ;

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

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

也在别名下:xdescribe.each(表)(姓名,fn)xdescribe.each`(名称,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. 成为 无限 ;
} ;

Prueba(Nombre,Fn,Tiempo)

TambiénConel别名:它(名称,fn,tiempo)

Todo lo que se reaviere en un archivo de prueba es el metodo测试Para Ejecutar Una Prueba。Por Ejeallo,Se asume unafunciónque mide las pulgadas de lluviainchesofrain()Debe Regresar Cero。La Prueba CompletaSería:

测试 '没有下雨' => {
预计 inchesofrain 成为 0. ;
} ;

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

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

Por Ejeallo,Se asume unafunciónque gregresa una lista de bebidasfetchbeveragelist()。Si EstaFunciónRegresaUna承诺Que Se Resuelve A UNA列表Que Contiene柠檬。Podemos proparlo con:

测试 '有柠檬' => {
返回 fetchbeveragelist. 然后 列表 => {
预计 列表 包含装有 '柠檬' ;
} ;
} ;

AUNQUELA LALLAMAA AL测试TerminaráInmediatame,La Prueba NoSeráfitchadaHastaQue Resuelva El承诺。

test.croncrent(名称,fn,超时)

也在别名下:它.CONCURRENT(名称,FN,超时)

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

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

El Primer Argumento Es El Nombre de la Prueba,El Segundo Argumento ES UnaFunciónConEl Codigo deieptivas是Ser Probadas。第三个论点(可选)是超时(以毫秒为单位),用于指定在中止前等待多长时间。注意:默认超时为5秒。

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

注意:使用MaxConcurrency.在配置中,以防止Jest同时执行超过指定的测试量

test.concurrent.each(表)(姓名,fn,超时)

也在别名下:它.CONCURRENT.EACH(表)(姓名,FN,超时)

test.concurrent.each.如果您继续使用不同的数据复制相同的测试。test.each.允许您一次编写测试并通过数据,测试全同步运行。

test.concurrent.each.有两个API:

1。test.concurrent.each(表)(姓名,fn,超时)

  • 桌子大批与传递到测试的参数的阵列FN.每行。
    • 笔记如果您通过1D数组的基元,则内部将映射到表I.E.[1,2,3] - > [[1],[2],[3]]
  • 名称细绳测试块的标题。
    • 通过使用位置注入参数来生成唯一的测试标题Printf.格式化
      • %P.-漂亮格式
      • %S.- 细绳。
      • %D.- 数字。
      • %一世- 整数。
      • %F- 浮点值。
      • %J.- json。
      • %O.- 目的。
      • %#- 测试用例的索引。
      • %%- 单百分号('%')。这不会消耗参数。
  • FN.功能测试是ran的,这是将在每个行中接收参数的函数参数,这必须是异步功能
  • 可选地,您可以提供一个超时(以毫秒为单位),用于指定在中止前等待每行的时间。注意:默认超时为5秒。

例子:

测试 同时 每个 [
[ 1 1 2 ]
[ 1 2 3. ]
[ 2 1 3. ]
] '.dd(%i,%i)' 一种 B. 预期的 => {
预计 一种 + B. 成为 预期的 ;
} ;

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

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

例子:

测试 同时 每个 `
a |B |预期的
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
` '返回$ a预期$ a增加$ b' { 一种 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)

测试 同时 只要 每个 `
a |B |预期的
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
` '返回$ a预期$ a增加$ b' 异步 { 一种 B. 预期的 } => {
预计 一种 + B. 成为 预期的 ;
} ;
测试 '不会被跑' => {
预计 1 / 0. 成为 无限 ;
} ;

test.concurrent.skip.each.each(表)(姓名,fn)

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

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

test.concurrent.skip.each.each.有两个API:

test.concurrent.skip.each.each(表)(姓名,fn)

测试 同时 跳过 每个 [
[ 1 1 2 ]
[ 1 2 3. ]
[ 2 1 3. ]
] '.dd(%i,%i)' 异步 一种 B. 预期的 => {
预计 一种 + B. 成为 预期的 ; //不会被跑
} ;
测试 “将是跑步” => {
预计 1 / 0. 成为 无限 ;
} ;

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

测试 同时 跳过 每个 `
a |B |预期的
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
` '返回$ a预期$ a增加$ b' 异步 { 一种 B. 预期的 } => {
预计 一种 + B. 成为 预期的 ; //不会被跑
} ;
测试 “将是跑步” => {
预计 1 / 0. 成为 无限 ;
} ;

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。
      • %O.- 目的。
      • %#- 测试用例的索引。
      • %%- 单百分号('%')。这不会消耗参数。
  • FN.功能测试是RAN的,这是将在每行中的参数作为函数参数接收的函数。
  • 可选地,您可以提供一个超时(以毫秒为单位),用于指定在中止前等待每行的时间。注意:默认超时为5秒。

例子:

测试 每个 [
[ 1 1 2 ]
[ 1 2 3. ]
[ 2 1 3. ]
] '.dd(%i,%i)' 一种 B. 预期的 => {
预计 一种 + B. 成为 预期的 ;
} ;

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

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

例子:

测试 每个 `
a |B |预期的
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
` '返回$ a预期$ a增加$ b' { 一种 B. 预期的 } => {
预计 一种 + B. 成为 预期的 ;
} ;

prueba.solo(名称,fn,tiempo)

也在别名下:它。(名称,fn,超时), 和适合(姓名,fn,超时)

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

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

Por Ejealto,Dimamos Que Se Tuviera Estas Pruebas:

测试 只要 '正在下雨' => {
预计 inchesofrain tobegreathan 0. ;
} ;
测试 '它没有下雪' => {
预计 inchesofsnow. 成为 0. ;
} ;

只有“下雨”测试将在该测试文件中运行,因为它运行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)

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

Cuando Se Trabaja en Una GranBaseDeCódigo,ES Frecuente Encontrar Alguna Prueba Que Falla de Manera Temporal。如果要跳过运行此测试,但您不想删除此代码,可以使用test.skip.指定一些跳过的测试。

Por Ejealto,Dimamos Que Se Tuviera Estas Pruebas:

测试 '正在下雨' => {
预计 inchesofrain tobegreathan 0. ;
} ;
测试 跳过 '它没有下雪' => {
预计 inchesofsnow. 成为 0. ;
} ;

Sóloseejecutaríalaprueba“它是raning”,pues seAgregótest.skip.La Otra prueba。

您可以评论测试,但通常有点更好test.skip.因为它将保持缩进和语法突出显示。

test.skip.each(表)(姓名,fn)

也在别名下:it.skip.each.each(表)(姓名,fn)xit.each(表)(名称,fn)xtest.each(表)(姓名,fn)it.skip.each``(姓名,fn)xit.each``(名字,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.当你计划写作测试时。这些测试将在摘要输出中突出显示最后,因此您知道您仍需要多次测试TODO。

笔记:如果您提供测试回调函数那么test.todo.会抛出错误。如果您已经实现了测试并且它被打破了,并且您不希望它运行,然后使用test.skip.反而。

API.

  • 名称细绳测试计划的标题。

例子:

const 添加 = 一种 B. => 一种 + B. ;
测试 去做 '添加应该是关联的' ;