GenericAssertions
GenericAssertions 类提供了一些断言方法，可用于对测试中的任意值进行断言。通过调用 expect() 可以创建一个新的 GenericAssertions 实例：
🌐 The GenericAssertions class provides assertion methods that can be used to make assertions about any values in the tests. A new instance of GenericAssertions is created by calling expect():
import { test, expect } from '@playwright/test';
test('assert a value', async ({ page }) => {
const value = 1;
expect(value).toBe(2);
});
方法
🌐 Methods
any
Added in: v1.9expect.any() 匹配由 constructor 创建的任何对象实例或相应的原始类型。在 expect(value).toEqual() 中使用它以执行模式匹配。
用法
// Match instance of a class.
class Example {}
expect(new Example()).toEqual(expect.any(Example));
// Match any number.
expect({ prop: 1 }).toEqual({ prop: expect.any(Number) });
// Match any string.
expect('abc').toEqual(expect.any(String));
参数
anything
Added in: v1.9expect.anything() 匹配除 null 和 undefined 之外的所有内容。将其用于 expect(value).toEqual() 中以执行模式匹配。
用法
const value = { prop: 1 };
expect(value).toEqual({ prop: expect.anything() });
expect(value).not.toEqual({ otherProp: expect.anything() });
arrayContaining
Added in: v1.9expect.arrayContaining() 匹配包含预期数组中所有元素的数组，顺序可以任意。请注意，接收到的数组可能是预期数组的超集，并包含一些额外的元素。
在 expect(value).toEqual() 中使用此方法来执行模式匹配。
🌐 Use this method inside expect(value).toEqual() to perform pattern matching.
用法
expect([1, 2, 3]).toEqual(expect.arrayContaining([3, 1]));
expect([1, 2, 3]).not.toEqual(expect.arrayContaining([1, 4]));
参数
arrayOf
Added in: v1.57expect.arrayOf() 匹配由 constructor 创建的对象数组或相应的原始类型。在 expect(value).toEqual() 中使用它来执行模式匹配。
用法
// Match instance of a class.
class Example {}
expect([new Example(), new Example()]).toEqual(expect.arrayOf(Example));
// Match any string.
expect(['a', 'b', 'c']).toEqual(expect.arrayOf(String));
参数
closeTo
Added in: v1.9比较浮点数的近似相等。在 expect(value).toEqual() 中使用此方法以执行模式匹配。如果仅比较两个数字，建议使用 expect(value).toBeCloseTo()。
🌐 Compares floating point numbers for approximate equality. Use this method inside expect(value).toEqual() to perform pattern matching. When just comparing two numbers, prefer expect(value).toBeCloseTo().
用法
expect({ prop: 0.1 + 0.2 }).not.toEqual({ prop: 0.3 });
expect({ prop: 0.1 + 0.2 }).toEqual({ prop: expect.closeTo(0.3, 5) });
参数
objectContaining
Added in: v1.9expect.objectContaining() 匹配包含并符合预期对象中所有属性的对象。请注意，接收到的对象可能是预期对象的超集，并且包含一些额外的属性。
在 expect(value).toEqual() 内使用此方法进行模式匹配。对象属性可以是匹配器，以进一步放宽期望。参见示例。
🌐 Use this method inside expect(value).toEqual() to perform pattern matching. Object properties can be matchers to further relax the expectation. See examples.
用法
// Assert some of the properties.
expect({ foo: 1, bar: 2 }).toEqual(expect.objectContaining({ foo: 1 }));
// Matchers can be used on the properties as well.
expect({ foo: 1, bar: 2 }).toEqual(expect.objectContaining({ bar: expect.any(Number) }));
// Complex matching of sub-properties.
expect({
list: [1, 2, 3],
obj: { prop: 'Hello world!', another: 'some other value' },
extra: 'extra',
}).toEqual(expect.objectContaining({
list: expect.arrayContaining([2, 3]),
obj: expect.objectContaining({ prop: expect.stringContaining('Hello') }),
}));
参数
stringContaining
Added in: v1.9expect.stringContaining() 匹配包含预期子字符串的字符串。在 expect(value).toEqual() 内使用此方法以执行模式匹配。
用法
expect('Hello world!').toEqual(expect.stringContaining('Hello'));
参数
stringMatching
Added in: v1.9expect.stringMatching() 匹配接收到的字符串，该字符串符合预期的模式。在 expect(value).toEqual() 中使用此方法进行模式匹配。
用法
expect('123ms').toEqual(expect.stringMatching(/\d+m?s/));
// Inside another matcher.
expect({
status: 'passed',
time: '123ms',
}).toEqual({
status: expect.stringMatching(/passed|failed/),
time: expect.stringMatching(/\d+m?s/),
});
参数
toBe
Added in: v1.9通过调用 Object.is 将值与 expected 进行比较。此方法通过引用而不是内容比较对象，类似于严格相等运算符 ===。
🌐 Compares value with expected by calling Object.is. This method compares objects by reference instead of their contents, similarly to the strict equality operator ===.
用法
const value = { prop: 1 };
expect(value).toBe(value);
expect(value).not.toBe({});
expect(value.prop).toBe(1);
参数
toBeCloseTo
Added in: v1.9比较浮点数是否大致相等。在比较浮点数时，应使用此方法，而不是 expect(value).toBe()。
🌐 Compares floating point numbers for approximate equality. Use this method instead of expect(value).toBe() when comparing floating point numbers.
用法
expect(0.1 + 0.2).not.toBe(0.3);
expect(0.1 + 0.2).toBeCloseTo(0.3, 5);
参数
toBeDefined
Added in: v1.9确保值不是 undefined。
🌐 Ensures that value is not undefined.
用法
const value = null;
expect(value).toBeDefined();
toBeFalsy
Added in: v1.9确保在布尔上下文中值为 false，即 false、0、''、null、undefined 或 NaN 之一。当你不关心具体值时使用此方法。
🌐 Ensures that value is false in a boolean context, one of false, 0, '', null, undefined or NaN. Use this method when you don't care about the specific value.
用法
const value = null;
expect(value).toBeFalsy();
toBeGreaterThan
Added in: v1.9确保 value > expected 用于数字或大整数值。
🌐 Ensures that value > expected for number or big integer values.
用法
const value = 42;
expect(value).toBeGreaterThan(1);
参数
toBeGreaterThanOrEqual
Added in: v1.9确保 value >= expected 用于数字或大整数值。
🌐 Ensures that value >= expected for number or big integer values.
用法
const value = 42;
expect(value).toBeGreaterThanOrEqual(42);
参数
toBeInstanceOf
Added in: v1.9确保值是某个类的实例。使用 instanceof 运算符。
🌐 Ensures that value is an instance of a class. Uses instanceof operator.
用法
expect(page).toBeInstanceOf(Page);
class Example {}
expect(new Example()).toBeInstanceOf(Example);
参数
toBeLessThan
Added in: v1.9确保 value < expected 用于数字或大整数值。
🌐 Ensures that value < expected for number or big integer values.
用法
const value = 42;
expect(value).toBeLessThan(100);
参数
toBeLessThanOrEqual
Added in: v1.9确保 value <= expected 用于数字或大整数值。
🌐 Ensures that value <= expected for number or big integer values.
用法
const value = 42;
expect(value).toBeLessThanOrEqual(42);
参数
toBeNaN
Added in: v1.9确保值为 NaN。
🌐 Ensures that value is NaN.
用法
const value = NaN;
expect(value).toBeNaN();
toBeNull
Added in: v1.9确保值为 null。
🌐 Ensures that value is null.
用法
const value = null;
expect(value).toBeNull();
toBeTruthy
Added in: v1.9确保在布尔上下文中值为 true，除了 false、0、''、null、undefined 或 NaN。当你不关心具体值时使用此方法。
🌐 Ensures that value is true in a boolean context, anything but false, 0, '', null, undefined or NaN. Use this method when you don't care about the specific value.
用法
const value = { example: 'value' };
expect(value).toBeTruthy();
toBeUndefined
Added in: v1.9确保值为 undefined。
🌐 Ensures that value is undefined.
用法
const value = undefined;
expect(value).toBeUndefined();
toContain(expected)
Added in: v1.9确保字符串值包含预期的子字符串。比较区分大小写。
🌐 Ensures that string value contains an expected substring. Comparison is case-sensitive.
用法
const value = 'Hello, World';
expect(value).toContain('World');
expect(value).toContain(',');
参数
toContain(expected)
Added in: v1.9确保值是 Array 或 Set，并且包含预期的项目。
🌐 Ensures that value is an Array or Set and contains an expected item.
用法
const value = [1, 2, 3];
expect(value).toContain(2);
expect(new Set(value)).toContain(2);
参数
toContainEqual
Added in: v1.9确保值是 Array 或 Set，并且包含一个等于预期的项目。
🌐 Ensures that value is an Array or Set and contains an item equal to the expected.
对于对象，该方法会递归地检查所有字段的相等性，而不是像 expect(value).toContain() 那样通过引用比较对象。
🌐 For objects, this method recursively checks equality of all fields, rather than comparing objects by reference as performed by expect(value).toContain().
对于原始值，此方法相当于 expect(value).toContain()。
🌐 For primitive values, this method is equivalent to expect(value).toContain().
用法
const value = [
{ example: 1 },
{ another: 2 },
{ more: 3 },
];
expect(value).toContainEqual({ another: 2 });
expect(new Set(value)).toContainEqual({ another: 2 });
参数
toEqual
Added in: v1.9将值的内容与 expected 的内容进行比较，执行“深度相等”检查。
🌐 Compares contents of the value with contents of expected, performing "deep equality" check.
对于对象，该方法会递归地检查所有字段的相等性，而不是像 expect(value).toBe() 那样通过引用比较对象。
🌐 For objects, this method recursively checks equality of all fields, rather than comparing objects by reference as performed by expect(value).toBe().
对于原始值，此方法相当于 expect(value).toBe()。
🌐 For primitive values, this method is equivalent to expect(value).toBe().
用法
const value = { prop: 1 };
expect(value).toEqual({ prop: 1 });
非严格相等
expect(value).toEqual() 会执行深度相等检查，比对接收到的值和预期值的内容。要确保两个对象引用同一个实例，应改用 expect(value).toBe()。
expect(value).toEqual() ignores undefined properties and array items, and does not insist on object types being equal. For stricter matching, use expect(value).toStrictEqual().
模式匹配
expect(value).toEqual() 也可以用来对对象、数组和原始类型进行模式匹配，借助以下匹配器：
- expect(value).any()
- expect(value).anything()
- expect(value).arrayContaining()
- expect(value).arrayOf()
- expect(value).closeTo()
- expect(value).objectContaining()
- expect(value).stringContaining()
- expect(value).stringMatching()
下面是一个断言复杂对象内的一些值的示例：
🌐 Here is an example that asserts some of the values inside a complex object:
expect({
list: [1, 2, 3],
obj: { prop: 'Hello world!', another: 'some other value' },
extra: 'extra',
}).toEqual(expect.objectContaining({
list: expect.arrayContaining([2, 3]),
obj: expect.objectContaining({ prop: expect.stringContaining('Hello') }),
}));
参数
toHaveLength
Added in: v1.9确保值具有一个 .length 属性，其值等于 expected。适用于数组和字符串。
🌐 Ensures that value has a .length property equal to expected. Useful for arrays and strings.
用法
expect('Hello, World').toHaveLength(12);
expect([1, 2, 3]).toHaveLength(3);
参数
toHaveProperty
Added in: v1.9确保对象上存在提供的 keyPath 属性，并可选择性地检查该属性是否等于 expected。相等性检查是递归进行的，类似于 expect(value).toEqual()。
🌐 Ensures that property at provided keyPath exists on the object and optionally checks that property is equal to the expected. Equality is checked recursively, similarly to expect(value).toEqual().
用法
const value = {
a: {
b: [42],
},
c: true,
};
expect(value).toHaveProperty('a.b');
expect(value).toHaveProperty('a.b', [42]);
expect(value).toHaveProperty('a.b[0]', 42);
expect(value).toHaveProperty('c');
expect(value).toHaveProperty('c', true);
参数
-
属性的路径。使用点表示法
a.b检查嵌套属性，使用索引a[2]表示法检查嵌套数组项。 -
用于与属性进行比较的可选预期值。
toMatch
Added in: v1.9确保字符串值与正则表达式匹配。
🌐 Ensures that string value matches a regular expression.
用法
const value = 'Is 42 enough?';
expect(value).toMatch(/Is \d+ enough/);
参数
toMatchObject
Added in: v1.9将值的内容与 expected 的内容进行比较，执行“深度相等”检查。与 expect(value).toEqual() 不同，它允许值中存在额外属性，因此你可以只检查对象属性的一个子集。
🌐 Compares contents of the value with contents of expected, performing "deep equality" check. Allows extra properties to be present in the value, unlike expect(value).toEqual(), so you can check just a subset of object properties.
比较数组时，项目数必须匹配，并且递归检查每个项目。
🌐 When comparing arrays, the number of items must match, and each item is checked recursively.
用法
const value = {
a: 1,
b: 2,
c: true,
};
expect(value).toMatchObject({ a: 1, c: true });
expect(value).toMatchObject({ b: 2, c: true });
expect([{ a: 1, b: 2 }]).toMatchObject([{ a: 1 }]);
参数
toStrictEqual
Added in: v1.9将值的内容与 expected 的内容 及 类型进行比较。
🌐 Compares contents of the value with contents of expected and their types.
与 expect(value).toEqual() 的区别：
🌐 Differences from expect(value).toEqual():
- 具有未定义属性的键会被检查。例如，
{ a: undefined, b: 2 }不匹配{ b: 2 }。 - 数组稀疏性已检查。例如，
[, 1]不匹配[undefined, 1]。 - 对象类型会被检查是否相等。例如，具有字段
a和b的类实例不会等于具有字段a和b的字面对象。
用法
const value = { prop: 1 };
expect(value).toStrictEqual({ prop: 1 });
参数
toThrow
Added in: v1.9调用该函数并确保它抛出错误。
🌐 Calls the function and ensures it throws an error.
可选择地将错误与预期值进行比较。允许的预期值为：
🌐 Optionally compares the error with expected. Allowed expected values:
- 正则表达式 - 错误信息应当符合该模式。
- 字符串 - 错误信息应包含该子字符串。
- 错误对象 - 错误消息应等于对象的 message 属性。
- 错误类 - 错误对象应当是该类的实例。
用法
expect(() => {
throw new Error('Something bad');
}).toThrow();
expect(() => {
throw new Error('Something bad');
}).toThrow(/something/);
expect(() => {
throw new Error('Something bad');
}).toThrow(Error);
参数
toThrowError
Added in: v1.9🌐 An alias for expect(value).toThrow().
用法
expect(() => {
throw new Error('Something bad');
}).toThrowError();
参数
属性
🌐 Properties
not
Added in: v1.9使断言检查相反的条件。例如，以下代码将通过：
🌐 Makes the assertion check for the opposite condition. For example, the following code passes:
const value = 1;
expect(value).not.toBe(2);
用法
expect(value).not
类型