GenericAssertions
GenericAssertions 类提供了断言方法，这些方法可用于对测试中的任何值进行断言。 GenericAssertions 的新实例是通过调用 expect() 创建的
import { test, expect } from '@playwright/test';
test('assert a value', async ({ page }) => {
const value = 1;
expect(value).toBe(2);
});
方法
any
添加于版本: 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
添加于版本: 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
添加于版本: v1.9expect.arrayContaining() 匹配一个数组，该数组包含预期数组中的所有元素，顺序不限。请注意，接收到的数组可能是预期数组的超集，并且包含一些额外的元素。
在 expect(value).toEqual() 中使用此方法来执行模式匹配。
用法
expect([1, 2, 3]).toEqual(expect.arrayContaining([3, 1]));
expect([1, 2, 3]).not.toEqual(expect.arrayContaining([1, 4]));
参数
closeTo
添加于版本: v1.9比较浮点数以进行近似相等性比较。在 expect(value).toEqual() 中使用此方法来执行模式匹配。当仅比较两个数字时，首选 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
添加于版本: v1.9expect.objectContaining() 匹配一个对象，该对象包含并匹配预期对象中的所有属性。请注意，接收到的对象可能是预期对象的超集，并且包含一些额外的属性。
在 expect(value).toEqual() 中使用此方法来执行模式匹配。对象属性可以是匹配器，以进一步放宽预期。请参阅示例。
用法
// 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
添加于版本: v1.9expect.stringContaining() 匹配包含预期子字符串的字符串。在 expect(value).toEqual() 中使用此方法来执行模式匹配。
用法
expect('Hello world!').toEqual(expect.stringContaining('Hello'));
参数
stringMatching
添加于版本: 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
添加于版本: v1.9通过调用 Object.is 将值与 expected 进行比较。此方法通过引用而不是内容来比较对象，类似于严格相等运算符 ===。
用法
const value = { prop: 1 };
expect(value).toBe(value);
expect(value).not.toBe({});
expect(value.prop).toBe(1);
参数
toBeCloseTo
添加于版本: v1.9比较浮点数以进行近似相等性比较。在比较浮点数时，请使用此方法代替 expect(value).toBe()。
用法
expect(0.1 + 0.2).not.toBe(0.3);
expect(0.1 + 0.2).toBeCloseTo(0.3, 5);
参数
toBeDefined
添加于版本: v1.9确保值不是 undefined。
用法
const value = null;
expect(value).toBeDefined();
toBeFalsy
添加于版本: v1.9确保值在布尔上下文中为 false，即 false、0、''、null、undefined 或 NaN 之一。当您不关心特定值时，请使用此方法。
用法
const value = null;
expect(value).toBeFalsy();
toBeGreaterThan
添加于版本: v1.9确保对于数字或大整数值，value > expected。
用法
const value = 42;
expect(value).toBeGreaterThan(1);
参数
toBeGreaterThanOrEqual
添加于版本: v1.9确保对于数字或大整数值，value >= expected。
用法
const value = 42;
expect(value).toBeGreaterThanOrEqual(42);
参数
toBeInstanceOf
添加于版本: v1.9确保值是类的实例。使用 instanceof 运算符。
用法
expect(page).toBeInstanceOf(Page);
class Example {}
expect(new Example()).toBeInstanceOf(Example);
参数
toBeLessThan
添加于版本: v1.9确保对于数字或大整数值，value < expected。
用法
const value = 42;
expect(value).toBeLessThan(100);
参数
toBeLessThanOrEqual
添加于版本: v1.9确保对于数字或大整数值，value <= expected。
用法
const value = 42;
expect(value).toBeLessThanOrEqual(42);
参数
toBeNaN
添加于版本: v1.9确保值为 NaN。
用法
const value = NaN;
expect(value).toBeNaN();
toBeNull
添加于版本: v1.9确保值为 null。
用法
const value = null;
expect(value).toBeNull();
toBeTruthy
添加于版本: v1.9确保值在布尔上下文中为 true，除了 false、0、''、null、undefined 或 NaN 之外的任何值。当您不关心特定值时，请使用此方法。
用法
const value = { example: 'value' };
expect(value).toBeTruthy();
toBeUndefined
添加于版本: v1.9确保值为 undefined。
用法
const value = undefined;
expect(value).toBeUndefined();
toContain(expected)
添加于版本: v1.9确保字符串值包含预期的子字符串。比较区分大小写。
用法
const value = 'Hello, World';
expect(value).toContain('World');
expect(value).toContain(',');
参数
toContain(expected)
添加于版本: v1.9确保值是 Array 或 Set，并且包含预期的项。
用法
const value = [1, 2, 3];
expect(value).toContain(2);
expect(new Set(value)).toContain(2);
参数
toContainEqual
添加于版本: v1.9确保值是 Array 或 Set，并且包含与预期值相等的项。
对于对象，此方法递归检查所有字段的相等性，而不是像 expect(value).toContain() 那样通过引用比较对象。
对于原始值，此方法等效于 expect(value).toContain()。
用法
const value = [
{ example: 1 },
{ another: 2 },
{ more: 3 },
];
expect(value).toContainEqual({ another: 2 });
expect(new Set(value)).toContainEqual({ another: 2 });
参数
toEqual
添加于版本: v1.9将值的内容与 expected 的内容进行比较，执行“深度相等”检查。
对于对象，此方法递归检查所有字段的相等性，而不是像 expect(value).toBe() 那样通过引用比较对象。
对于原始值，此方法等效于 expect(value).toBe()。
用法
const value = { prop: 1 };
expect(value).toEqual({ prop: 1 });
非严格相等
expect(value).toEqual() 执行深度相等检查，以比较接收值和预期值的内容。要确保两个对象引用相同的实例，请改用 expect(value).toBe()。
expect(value).toEqual() 忽略 undefined 属性和数组项，并且不坚持对象类型相等。对于更严格的匹配，请使用 expect(value).toStrictEqual()。
模式匹配
expect(value).toEqual() 也可以用于对对象、数组和原始类型执行模式匹配，借助以下匹配器
- expect(value).any()
- expect(value).anything()
- expect(value).arrayContaining()
- expect(value).closeTo()
- expect(value).objectContaining()
- expect(value).stringContaining()
- expect(value).stringMatching()
这是一个断言复杂对象内部某些值的示例
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
添加于版本: v1.9确保值具有等于 expected 的 .length 属性。对数组和字符串很有用。
用法
expect('Hello, World').toHaveLength(12);
expect([1, 2, 3]).toHaveLength(3);
参数
toHaveProperty
添加于版本: v1.9确保对象上存在提供的 keyPath 处的属性，并可选择检查该属性是否等于 expected。相等性以递归方式检查，类似于 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
添加于版本: v1.9确保字符串值与正则表达式匹配。
用法
const value = 'Is 42 enough?';
expect(value).toMatch(/Is \d+ enough/);
参数
toMatchObject
添加于版本: v1.9将值的内容与 expected 的内容进行比较，执行“深度相等”检查。与 expect(value).toEqual() 不同，允许值中存在额外的属性，因此您可以仅检查对象属性的子集。
比较数组时，项的数量必须匹配，并且每个项都以递归方式检查。
用法
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
添加于版本: v1.9比较值的内容与 expected 的内容以及它们的类型。
与 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
添加于版本: v1.9调用函数并确保它抛出错误。
可选择将错误与 expected 进行比较。允许的预期值
- 正则表达式 - 错误消息应匹配该模式。
- 字符串 - 错误消息应包含该子字符串。
- 错误对象 - 错误消息应等于该对象的消息属性。
- 错误类 - 错误对象应为该类的实例。
用法
expect(() => {
throw new Error('Something bad');
}).toThrow();
expect(() => {
throw new Error('Something bad');
}).toThrow(/something/);
expect(() => {
throw new Error('Something bad');
}).toThrow(Error);
参数
toThrowError
添加于版本: v1.9用法
expect(() => {
throw new Error('Something bad');
}).toThrowError();
参数
属性
not
添加于版本: v1.9使断言检查相反的条件。例如，以下代码通过
const value = 1;
expect(value).not.toBe(2);
用法
expect(value).not
类型