chore: support arrayOf

Author: pavelfeldman

docs/src/api/class-genericassertions.md

@@ -354,6 +354,7 @@ expect(value).toEqual({ prop: 1 });
 * [`method: GenericAssertions.any`]
 * [`method: GenericAssertions.anything`]
 * [`method: GenericAssertions.arrayContaining`]
+* [`method: GenericAssertions.arrayOf`]
 * [`method: GenericAssertions.closeTo`]
 * [`method: GenericAssertions.objectContaining`]
 * [`method: GenericAssertions.stringContaining`]
@@ -625,6 +626,31 @@ expect([1, 2, 3]).not.toEqual(expect.arrayContaining([1, 4]));
 Expected array that is a subset of the received value.
 
 
+## method: GenericAssertions.arrayOf
+* since: v1.57
+
+`expect.arrayOf()` matches array of objects created from the [`param: constructor`] or a corresponding primitive type. Use it inside [`method: GenericAssertions.toEqual`] to perform pattern matching.
+
+**Usage**
+
+```js
+// Match instance of a class.
+class Example {}
+expect([new Example()]).toEqual(expect.arrayOf(Example));
+
+// Match any number.
+expect([{ prop: 1 }]).toEqual({ prop: expect.arrayOf(Number) });
+
+// Match any string.
+expect(['abc']).toEqual(expect.arrayOf(String));
+```
+
+### param: GenericAssertions.arrayOf.constructor
+* since: v1.57
+- `constructor` <[Function]>
+
+Constructor of the expected object like `ExampleClass`, or a primitive boxed type like `Number`.
+
 
 ## method: GenericAssertions.closeTo
 * since: v1.9

packages/playwright/types/test.d.ts

@@ -7728,6 +7728,30 @@ interface AsymmetricMatchers {
    * @param expected Expected array that is a subset of the received value.
    */
   arrayContaining(sample: Array<unknown>): AsymmetricMatcher;
+  /**
+   * `expect.arrayOf()` matches array of objects created from the
+   * [`constructor`](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-array-of-option-constructor)
+   * or a corresponding primitive type. Use it inside
+   * [expect(value).toEqual(expected)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-to-equal)
+   * to perform pattern matching.
+   *
+   * **Usage**
+   *
+   * ```js
+   * // Match instance of a class.
+   * class Example {}
+   * expect([new Example()]).toEqual(expect.arrayOf(Example));
+   *
+   * // Match any number.
+   * expect([{ prop: 1 }]).toEqual({ prop: expect.arrayOf(Number) });
+   *
+   * // Match any string.
+   * expect(['abc']).toEqual(expect.arrayOf(String));
+   * ```
+   *
+   * @param constructor Constructor of the expected object like `ExampleClass`, or a primitive boxed type like `Number`.
+   */
+  arrayOf(sample: unknown): AsymmetricMatcher;
   /**
    * Compares floating point numbers for approximate equality. Use this method inside
    * [expect(value).toEqual(expected)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-to-equal)
@@ -8111,6 +8135,7 @@ interface GenericAssertions<R> {
    * - [expect(value).any(constructor)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-any)
    * - [expect(value).anything()](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-anything)
    * - [expect(value).arrayContaining(expected)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-array-containing)
+   * - [expect(value).arrayOf(constructor)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-array-of)
    * - [expect(value).closeTo(expected[, numDigits])](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-close-to)
    * - [expect(value).objectContaining(expected)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-object-containing)
    * - [expect(value).stringContaining(expected)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-string-containing)
@@ -8281,7 +8306,30 @@ interface GenericAssertions<R> {
    * @param expected Expected error message or error object.
    */
   toThrowError(error?: unknown): R;
-
+  /**
+   * `expect.arrayOf()` matches array of objects created from the
+   * [`constructor`](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-array-of-option-constructor)
+   * or a corresponding primitive type. Use it inside
+   * [expect(value).toEqual(expected)](https://playwright.dev/docs/api/class-genericassertions#generic-assertions-to-equal)
+   * to perform pattern matching.
+   *
+   * **Usage**
+   *
+   * ```js
+   * // Match instance of a class.
+   * class Example {}
+   * expect([new Example()]).toEqual(expect.arrayOf(Example));
+   *
+   * // Match any number.
+   * expect([{ prop: 1 }]).toEqual({ prop: expect.arrayOf(Number) });
+   *
+   * // Match any string.
+   * expect(['abc']).toEqual(expect.arrayOf(String));
+   * ```
+   *
+   * @param constructor Constructor of the expected object like `ExampleClass`, or a primitive boxed type like `Number`.
+   */
+  arrayOf(constructor: Function): void;
 }
 
 type FunctionAssertions = {

tests/playwright-test/expect.spec.ts

@@ -1301,3 +1301,21 @@ test('multiple custom asymmetric matchers in async expect should present the cor
   expect(result.output).toContain('-   \"aProperty\": isUndefined<>');
   expect(result.output).toContain('+   \"aProperty\": \"foo\"');
 });
+
+test('should support arrayOf', async ({ runInlineTest }) => {
+  const result = await runInlineTest({
+    'expect-test.spec.ts': `
+      import { test, expect } from '@playwright/test';
+      test('pass', () => {
+        expect([1,2,3]).toEqual(expect.arrayOf(expect.any(Number)));
+      });
+      test('fail', () => {
+        expect([1,2,'3']).toEqual(expect.arrayOf(expect.any(Number)));
+      });
+    `
+  });
+  expect(result.exitCode).toBe(1);
+  expect(result.passed).toBe(1);
+  expect(result.failed).toBe(1);
+  expect(result.output).toContain('ArrayOf Any<Number>');
+});

utils/generate_types/overrides-test.d.ts

@@ -321,6 +321,7 @@ interface AsymmetricMatchers {
   any(sample: unknown): AsymmetricMatcher;
   anything(): AsymmetricMatcher;
   arrayContaining(sample: Array<unknown>): AsymmetricMatcher;
+  arrayOf(sample: unknown): AsymmetricMatcher;
   closeTo(sample: number, precision?: number): AsymmetricMatcher;
   objectContaining(sample: Record<string, unknown>): AsymmetricMatcher;
   stringContaining(sample: string): AsymmetricMatcher;