diff --git a/api/expect.md b/api/expect.md index 161272ec..f5da0000 100644 --- a/api/expect.md +++ b/api/expect.md @@ -334,7 +334,7 @@ test('we don\'t have apples', () => { - **类型:** `() => Awaitable` -`toBeNullable` simply asserts if something is nullable (`null` or `undefined`). +`toBeNullable` 简单地断言某些内容是否为 null（`null` 或 `undefined`）。 ```ts import { expect, test } from 'vitest' @@ -435,7 +435,7 @@ test('stock is type of string', () => { ``` :::warning -`toBeTypeOf` uses the native `typeof` operator under the hood with all its quirks, most notably that the value `null` has type `object`. +`toBeTypeOf` 底层使用原生 `typeof` 运算符（包含其固有特性），最显著的表现是 `null` 值会被判定为 `object` 类型。 ```ts test('toBeTypeOf cannot check for null or array', () => { @@ -883,7 +883,7 @@ test('matches snapshot', () => { }) ``` -我们还可以提供一个对象的形状，如果我们只是测试对象的形状，而不需要它完全兼容： +当我们不需要完全兼容时，可以仅对对象的接口规范进行测试： ```ts import { expect, test } from 'vitest' @@ -919,7 +919,7 @@ test('matches inline snapshot', () => { }) ``` -如果我么只是在测试对象的形状，而不需要它 100% 兼容，我们也可以提供一个对象的形状。 +当我们不需要完全兼容时，可以仅对对象的接口规范进行测试： ```ts import { expect, test } from 'vitest' @@ -1081,7 +1081,7 @@ test('calls mock1 after mock2', () => { }) ``` -## toHaveBeenCalledExactlyOnceWit +## toHaveBeenCalledExactlyOnceWith - **类型**: `(...args: any[]) => Awaitable` @@ -1308,7 +1308,7 @@ test('spy function resolved a value two times', async () => { ## toHaveResolvedWith -- **类型**: `(returnValue: any) => Awaitable` +- **类型:** `(returnValue: any) => Awaitable` 您可以调用此断言来检查函数是否至少成功解析过一次某个值。需要将 spy 函数传递给`expect`。 @@ -1328,7 +1328,7 @@ test('spy function resolved a product', async () => { ## toHaveLastResolvedWith -- **Type**: `(returnValue: any) => Awaitable` +- **类型:** `(returnValue: any) => Awaitable` 您可以调用此断言来检查函数在上次调用时是否已成功解析某个值。需要将 spy 函数传递给`expect`。 @@ -1349,13 +1349,13 @@ test('spy function resolves bananas on a last call', async () => { ## toHaveNthResolvedWith -- **Type**: `(time: number, returnValue: any) => Awaitable` +- **类型:** `(time: number, returnValue: any) => Awaitable` -您可以调用此断言来检查函数在特定调用中是否成功解析了某个值。需要将一个间谍函数（spy function）传递给 `expect`。 +你可以调用此断言来检查函数在特定调用中是否成功解析了某个值。需要将一个 spy 函数传递给 `expect`。 如果函数返回了一个 promise，但尚未 resolved，则将会失败。 -The count starts at 1. So, to check the second entry, you would write `.toHaveNthResolvedWith(2, ...)`. +从 1 开始计数。因此，要检查第二个参数，你需要编写 `.toHaveNthResolvedWith(2, ...)`。 ```ts import { expect, test, vi } from 'vitest' @@ -1372,12 +1372,12 @@ test('spy function returns bananas on second call', async () => { ## called 4.1.0 {#called} -- **Type:** `Assertion` (property, not a method) +- **类型:** `Assertion` (property, not a method) -Chai-style assertion that checks if a spy was called at least once. This is equivalent to `toHaveBeenCalled()`. +这是一个检查 spy 函数是否至少被调用一次的 Chai 风格断言，等价于 `toHaveBeenCalled()`。 ::: tip -This is a property assertion following sinon-chai conventions. Access it without parentheses: `expect(spy).to.have.been.called` +这是一个遵循 sinon-chai 约定的属性断言。使用时无需括号：`expect(spy).to.have.been.called` ::: ```ts @@ -1389,15 +1389,15 @@ test('spy was called', () => { spy() expect(spy).to.have.been.called - expect(spy).to.not.have.been.called // negation + expect(spy).to.not.have.been.called // 否定断言 }) ``` ## callCount 4.1.0 {#callcount} -- **Type:** `(count: number) => void` +- **类型:** `(count: number) => void` -Chai-style assertion that checks if a spy was called a specific number of times. This is equivalent to `toHaveBeenCalledTimes(count)`. +Chai 风格断言，用于检查 spy 函数被调用的次数是否符合预期。等价于 `toHaveBeenCalledTimes(count)`。 ```ts import { expect, test, vi } from 'vitest' @@ -1415,9 +1415,9 @@ test('spy call count', () => { ## calledWith 4.1.0 {#calledwith} -- **Type:** `(...args: any[]) => void` +- **类型:** `(...args: any[]) => void` -Chai-style assertion that checks if a spy was called with specific arguments at least once. This is equivalent to `toHaveBeenCalledWith(...args)`. +Chai 风格断言，用于检查 spy 函数是否至少以指定参数被调用过一次。等价于 `toHaveBeenCalledWith(...args)`。 ```ts import { expect, test, vi } from 'vitest' @@ -1435,12 +1435,12 @@ test('spy called with arguments', () => { ## calledOnce 4.1.0 {#calledonce} -- **Type:** `Assertion` (property, not a method) +- **类型:** `Assertion` (property, not a method) -Chai-style assertion that checks if a spy was called exactly once. This is equivalent to `toHaveBeenCalledOnce()`. +Chai 风格断言，用于检查 spy 函数是否恰好被调用了一次。等价于 `toHaveBeenCalledOnce()`。 ::: tip -This is a property assertion following sinon-chai conventions. Access it without parentheses: `expect(spy).to.have.been.calledOnce` +这是遵循 sinon-chai 约定的属性断言，使用时无需括号：`expect(spy).to.have.been.calledOnce` ::: ```ts @@ -1457,9 +1457,9 @@ test('spy called once', () => { ## calledOnceWith 4.1.0 {#calledoncewith} -- **Type:** `(...args: any[]) => void` +- **类型:** `(...args: any[]) => void` -Chai-style assertion that checks if a spy was called exactly once with specific arguments. This is equivalent to `toHaveBeenCalledExactlyOnceWith(...args)`. +Chai 风格断言，用于检查 spy 函数是否恰好以指定参数被调用了一次。等价于 `toHaveBeenCalledExactlyOnceWith(...args)`。 ```ts import { expect, test, vi } from 'vitest' @@ -1475,12 +1475,12 @@ test('spy called once with arguments', () => { ## calledTwice 4.1.0 {#calledtwice} -- **Type:** `Assertion` (property, not a method) +- **类型:** `Assertion` (property, not a method) -Chai-style assertion that checks if a spy was called exactly twice. This is equivalent to `toHaveBeenCalledTimes(2)`. +Chai 风格断言，用于检查 spy 函数是否恰好被调用了两次。等价于 `toHaveBeenCalledTimes(2)`。 ::: tip -This is a property assertion following sinon-chai conventions. Access it without parentheses: `expect(spy).to.have.been.calledTwice` +这是遵循 sinon-chai 约定的属性断言，使用时无需括号：`expect(spy).to.have.been.calledTwice` ::: ```ts @@ -1498,12 +1498,12 @@ test('spy called twice', () => { ## calledThrice 4.1.0 {#calledthrice} -- **Type:** `Assertion` (property, not a method) +- **类型:** `Assertion` (property, not a method) -Chai-style assertion that checks if a spy was called exactly three times. This is equivalent to `toHaveBeenCalledTimes(3)`. +Chai 风格断言，用于检查 spy 函数是否恰好被调用了三次。等价于 `toHaveBeenCalledTimes(3)`。 ::: tip -This is a property assertion following sinon-chai conventions. Access it without parentheses: `expect(spy).to.have.been.calledThrice` +这是遵循 sinon-chai 约定的属性断言，使用时无需括号：`expect(spy).to.have.been.calledThrice` ::: ```ts @@ -1522,9 +1522,9 @@ test('spy called thrice', () => { ## lastCalledWith -- **Type:** `(...args: any[]) => void` +- **类型:** `(...args: any[]) => void` -Chai-style assertion that checks if the last call to a spy was made with specific arguments. This is equivalent to `toHaveBeenLastCalledWith(...args)`. +Chai 风格断言，用于检查 spy 函数最后一次调用是否使用了指定参数。等价于 `toHaveBeenLastCalledWith(...args)`。 ```ts import { expect, test, vi } from 'vitest' @@ -1541,9 +1541,9 @@ test('spy last called with', () => { ## nthCalledWith -- **Type:** `(n: number, ...args: any[]) => void` +- **类型:** `(n: number, ...args: any[]) => void` -Chai-style assertion that checks if the nth call to a spy was made with specific arguments. This is equivalent to `toHaveBeenNthCalledWith(n, ...args)`. +Chai 风格断言，用于检查 spy 函数第 n 次调用是否使用了指定参数。等价于 `toHaveBeenNthCalledWith(n, ...args)`。 ```ts import { expect, test, vi } from 'vitest' @@ -1561,12 +1561,12 @@ test('spy nth called with', () => { ## returned 4.1.0 {#returned} -- **Type:** `Assertion` (property, not a method) +- **类型:** `Assertion` (property, not a method) -Chai-style assertion that checks if a spy returned successfully at least once. This is equivalent to `toHaveReturned()`. +Chai 风格断言，用于检查 spy 函数是否至少成功返回过一次。等价于 `toHaveReturned()`。 ::: tip -This is a property assertion following sinon-chai conventions. Access it without parentheses: `expect(spy).to.have.returned` +这是遵循 sinon-chai 约定的属性断言，使用时无需括号：`expect(spy).to.have.returned` ::: ```ts @@ -1583,9 +1583,9 @@ test('spy returned', () => { ## returnedWith 4.1.0 {#returnedwith} -- **Type:** `(value: any) => void` +- **类型:** `(value: any) => void` -Chai-style assertion that checks if a spy returned a specific value at least once. This is equivalent to `toHaveReturnedWith(value)`. +Chai 风格断言，用于检查 spy 函数是否至少返回过一次指定的值。等价于 `toHaveReturnedWith(value)`。 ```ts import { expect, test, vi } from 'vitest' @@ -1605,9 +1605,9 @@ test('spy returned with value', () => { ## returnedTimes 4.1.0 {#returnedtimes} -- **Type:** `(count: number) => void` +- **类型:** `(count: number) => void` -Chai-style assertion that checks if a spy returned successfully a specific number of times. This is equivalent to `toHaveReturnedTimes(count)`. +Chai 风格断言，用于检查 spy 函数成功返回的次数是否符合预期。等价于 `toHaveReturnedTimes(count)`。 ```ts import { expect, test, vi } from 'vitest' @@ -1625,9 +1625,9 @@ test('spy returned times', () => { ## lastReturnedWith -- **Type:** `(value: any) => void` +- **类型:** `(value: any) => void` -Chai-style assertion that checks if the last return value of a spy matches the expected value. This is equivalent to `toHaveLastReturnedWith(value)`. +Chai 风格断言，用于检查 spy 函数最后一次返回值是否与预期值匹配。等价于 `toHaveLastReturnedWith(value)`。 ```ts import { expect, test, vi } from 'vitest' @@ -1646,9 +1646,9 @@ test('spy last returned with', () => { ## nthReturnedWith -- **Type:** `(n: number, value: any) => void` +- **类型:** `(n: number, value: any) => void` -Chai-style assertion that checks if the nth return value of a spy matches the expected value. This is equivalent to `toHaveNthReturnedWith(n, value)`. +Chai 风格断言，用于检查 spy 函数第 n 次返回值是否与预期值匹配。等价于 `toHaveNthReturnedWith(n, value)`。 ```ts import { expect, test, vi } from 'vitest' @@ -1669,9 +1669,9 @@ test('spy nth returned with', () => { ## calledBefore 4.1.0 {#calledbefore} -- **Type:** `(mock: MockInstance, failIfNoFirstInvocation?: boolean) => void` +- **类型:** `(mock: MockInstance, failIfNoFirstInvocation?: boolean) => void` -Chai-style assertion that checks if a spy was called before another spy. This is equivalent to `toHaveBeenCalledBefore(mock, failIfNoFirstInvocation)`. +Chai 风格断言，用于检查一个 spy 函数是否在另一个 spy 函数之前被调用。等价于 `toHaveBeenCalledBefore(mock, failIfNoFirstInvocation)`。 ```ts import { expect, test, vi } from 'vitest' @@ -1689,9 +1689,9 @@ test('spy called before another', () => { ## calledAfter 4.1.0 {#calledafter} -- **Type:** `(mock: MockInstance, failIfNoFirstInvocation?: boolean) => void` +- **类型:** `(mock: MockInstance, failIfNoFirstInvocation?: boolean) => void` -Chai-style assertion that checks if a spy was called after another spy. This is equivalent to `toHaveBeenCalledAfter(mock, failIfNoFirstInvocation)`. +Chai 风格断言，用于检查一个 spy 函数是否在另一个 spy 函数之后被调用。等价于 `toHaveBeenCalledAfter(mock, failIfNoFirstInvocation)`。 ```ts import { expect, test, vi } from 'vitest' @@ -1707,8 +1707,8 @@ test('spy called after another', () => { }) ``` -::: tip Migration Guide -For a complete guide on migrating from Mocha+Chai+Sinon to Vitest, see the [Migration Guide](/guide/migration#mocha-chai-sinon). +::: tip 迁移指南 +完整的从 Mocha+Chai+Sinon 迁移到 Vitest 的指南，请参阅 [迁移指南](/guide/migration#mocha-chai-sinon)。 ::: ## toSatisfy @@ -1988,7 +1988,7 @@ test('basket includes fuji', () => { - **类型:** `(expected: any) => any` -当与相等检查一起使用时，如果值的形状相似，该非对称匹配器将返回 `true`。 +当与相等检查一起使用时，如果值的接口规范相似，该非对称匹配器将返回 `true`。 ```ts import { expect, test } from 'vitest' @@ -2077,17 +2077,17 @@ import { type } from 'arktype' test('email validation', () => { const user = { email: 'john@example.com' } - // using Zod + // 使用 Zod expect(user).toEqual({ email: expect.schemaMatching(z.string().email()), }) - // using Valibot + // 使用 Valibot expect(user).toEqual({ email: expect.schemaMatching(v.pipe(v.string(), v.email())) }) - // using ArkType + // 使用 ArkType expect(user).toEqual({ email: expect.schemaMatching(type('string.email')), }) @@ -2095,7 +2095,7 @@ test('email validation', () => { ``` :::tip -You can use `expect.not` with this matcher to negate the expected value. +可以通过 `expect.not` 结合此匹配器来对期望值进行取反断言。 ::: ## expect.addSnapshotSerializer @@ -2107,7 +2107,7 @@ You can use `expect.not` with this matcher to negate the expected value. 如果需要添加自定义序列化程序，应该在 [`setupFiles`](/config/setupfiles) 中调用此方法。这将影响每个快照。 :::tip -如果以前将 Vue CLI 与 Jest 一起使用，需要安装 [jest-serializer-vue](https://www.npmjs.com/package/jest-serializer-vue)。 否则，的快照将被包裹在一个字符串中，其中 `"` 是要转义的。 +如果以前将 Vue CLI 与 Jest 一起使用，需要安装 [jest-serializer-vue](https://www.npmjs.com/package/jest-serializer-vue)。 否则，快照将被包裹在一个字符串中，其中 `"` 是要转义的。 ::: ## expect.extend diff --git a/guide/migration.md b/guide/migration.md index 669afa39..0c37e49d 100644 --- a/guide/migration.md +++ b/guide/migration.md @@ -711,7 +711,7 @@ expect(spy).to.have.been.calledOnce expect(spy).to.have.been.calledWith('arg1', 'arg2') ``` -#### 完整的 Chai 风格断言支持 {#}complete-chai-style-assertion-support} +#### 完整的 Chai 风格断言支持 {#complete-chai-style-assertion-support} Vitest supports all common sinon-chai assertions: diff --git a/guide/open-telemetry.md b/guide/open-telemetry.md index 905ad5a5..371a47b0 100644 --- a/guide/open-telemetry.md +++ b/guide/open-telemetry.md @@ -141,7 +141,7 @@ export default defineConfig({ 生成追踪数据时，请像往常一样运行 Vitest，无论是 watch 模式还是运行模式均可。Vitest 会在所有操作完成后手动调用 `sdk.shutdown()` 以确保追踪数据得到正确处理。 -你可以使用任何支持 OpenTelemetry API 的开源或商业产品来查看追踪。。如果是初次接触 OpenTelemetry，我们推荐从 [Jaeger](https://www.jaegertracing.io/docs/2.11/getting-started/#all-in-one) 开始，因为它真的很容易设置。 +你可以使用任何支持 OpenTelemetry API 的开源或商业产品来查看追踪。如果是初次接触 OpenTelemetry，我们推荐从 [Jaeger](https://www.jaegertracing.io/docs/2.11/getting-started/#all-in-one) 开始，因为它真的很容易设置。