yujunjun/playwright
1
0
Fork 0
mirror of https://github.com/microsoft/playwright.git synced 2025-06-26 21:40:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: embed expect types (#13609)

Browse Source
This commit is contained in:
Pavel Feldman 2022-04-18 09:54:40 -08:00 committed by GitHub
parent 71fbd2454e
commit eafb92f6a3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 374 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

368
packages/playwright-test/types/expect-types.d.ts vendored Normal file
View File

@ -0,0 +1,368 @@
/**
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
// -------------- Playwright -------------
// - Matcher types are relaxed in the overrides.
//
// import type { Config } from '@jest/types';
// import type * as jestMatcherUtils from 'jest-matcher-utils';
// import { INTERNAL_MATCHER_FLAG } from './jestMatchersObject';
//
// export declare type SyncExpectationResult = {
// pass: boolean;
// message: () => string;
// };
// export declare type AsyncExpectationResult = Promise<SyncExpectationResult>;
// export declare type ExpectationResult = SyncExpectationResult | AsyncExpectationResult;
// export declare type RawMatcherFn<T extends MatcherState = MatcherState> = {
// (this: T, received: any, expected: any, options?: any): ExpectationResult;
// [INTERNAL_MATCHER_FLAG]?: boolean;
// };
// export declare type ThrowingMatcherFn = (actual: any) => void;
// export declare type PromiseMatcherFn = (actual: any) => Promise<void>;
// ---------------------------------------
export declare type Tester = (a: any, b: any) => boolean | undefined;
export declare type MatcherState = {
assertionCalls: number;
currentTestName?: string;
dontThrow?: () => void;
error?: Error;
equals: (a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean) => boolean;
expand?: boolean;
expectedAssertionsNumber?: number | null;
expectedAssertionsNumberError?: Error;
isExpectingAssertions?: boolean;
isExpectingAssertionsError?: Error;
isNot: boolean;
promise: string;
suppressedErrors: Array<Error>;
// -------------- Playwright -------------
// - Inline type
// testPath?: Config.Path;
testPath?: string;
// ---------------------------------------
// -------------- Playwright -------------
// - Further relax type in order to not drag the dependencies.
// utils: typeof jestMatcherUtils & {
// iterableEquality: Tester;
// subsetEquality: Tester;
// };
utils: any;
// ---------------------------------------
};
// -------------- Playwright -------------
// - Matcher types are relaxed in the override.
//
// export interface AsymmetricMatcher {
// asymmetricMatch(other: unknown): boolean;
// toString(): string;
// getExpectedType?(): string;
// toAsymmetricMatcher?(): string;
// }
//
// export declare type MatchersObject<T extends MatcherState = MatcherState> = {
// [id: string]: RawMatcherFn<T>;
// };
// export declare type ExpectedAssertionsErrors = Array<{
// actual: string | number;
// error: Error;
// expected: string;
// }>;
// ---------------------------------------
// -------------- Playwright -------------
// Following are inlined in the expect override.
// interface InverseAsymmetricMatchers {
// arrayContaining(sample: Array<unknown>): AsymmetricMatcher;
// objectContaining(sample: Record<string, unknown>): AsymmetricMatcher;
// stringContaining(expected: string): AsymmetricMatcher;
// stringMatching(expected: string | RegExp): AsymmetricMatcher;
// }
// interface AsymmetricMatchers extends InverseAsymmetricMatchers {
// any(expectedObject: unknown): AsymmetricMatcher;
// anything(): AsymmetricMatcher;
// }
// interface ExtraAsymmetricMatchers {
// [id: string]: (...sample: [unknown, ...Array<unknown>]) => AsymmetricMatcher;
// }
// export declare type Expect<State extends MatcherState = MatcherState> = {
// <T = unknown>(actual: T): Matchers<void>;
// addSnapshotSerializer(serializer: unknown): void;
// assertions(numberOfAssertions: number): void;
// extend<T extends MatcherState = State>(matchers: MatchersObject<T>): void;
// extractExpectedAssertionsErrors: () => ExpectedAssertionsErrors;
// getState(): State;
// hasAssertions(): void;
// setState(state: Partial<State>): void;
// } & AsymmetricMatchers & ExtraAsymmetricMatchers & {
// not: InverseAsymmetricMatchers & ExtraAsymmetricMatchers;
// };
// ---------------------------------------
// -------------- Playwright -------------
// - Some of the removed matchers below require jest.fn
// - Some are overridden.
// - Some are missing (inline snapshot).
// ---------------------------------------
export interface Matchers<R> {
// /**
// * Ensures the last call to a mock function was provided specific args.
// */
// lastCalledWith(...args: Array<unknown>): R;
// /**
// * Ensure that the last call to a mock function has returned a specified value.
// */
// lastReturnedWith(value: unknown): R;
// /**
// * If you know how to test something, `.not` lets you test its opposite.
// */
// not: Matchers<R>;
// /**
// * Ensure that a mock function is called with specific arguments on an Nth call.
// */
// nthCalledWith(nthCall: number, ...args: Array<unknown>): R;
// /**
// * Ensure that the nth call to a mock function has returned a specified value.
// */
// nthReturnedWith(n: number, value: unknown): R;
// /**
// * Use resolves to unwrap the value of a fulfilled promise so any other
// * matcher can be chained. If the promise is rejected the assertion fails.
// */
// resolves: Matchers<Promise<R>>;
// /**
// * Unwraps the reason of a rejected promise so any other matcher can be chained.
// * If the promise is fulfilled the assertion fails.
// */
// rejects: Matchers<Promise<R>>;
/**
* Checks that a value is what you expect. It uses `===` to check strict equality.
* Don't use `toBe` with floating-point numbers.
*/
toBe(expected: unknown): R;
// /**
// * Ensures that a mock function is called.
// */
// toBeCalled(): R;
// /**
// * Ensures that a mock function is called an exact number of times.
// */
// toBeCalledTimes(expected: number): R;
// /**
// * Ensure that a mock function is called with specific arguments.
// */
// toBeCalledWith(...args: Array<unknown>): R;
/**
* Using exact equality with floating point numbers is a bad idea.
* Rounding means that intuitive things fail.
* The default for numDigits is 2.
*/
toBeCloseTo(expected: number, numDigits?: number): R;
/**
* Ensure that a variable is not undefined.
*/
toBeDefined(): R;
/**
* When you don't care what a value is, you just want to
* ensure a value is false in a boolean context.
*/
toBeFalsy(): R;
/**
* For comparing floating point numbers.
*/
toBeGreaterThan(expected: number | bigint): R;
/**
* For comparing floating point numbers.
*/
toBeGreaterThanOrEqual(expected: number | bigint): R;
/**
* Ensure that an object is an instance of a class.
* This matcher uses `instanceof` underneath.
*/
toBeInstanceOf(expected: Function): R;
/**
* For comparing floating point numbers.
*/
toBeLessThan(expected: number | bigint): R;
/**
* For comparing floating point numbers.
*/
toBeLessThanOrEqual(expected: number | bigint): R;
/**
* This is the same as `.toBe(null)` but the error messages are a bit nicer.
* So use `.toBeNull()` when you want to check that something is null.
*/
toBeNull(): R;
/**
* Use when you don't care what a value is, you just want to ensure a value
* is true in a boolean context. In JavaScript, there are six falsy values:
* `false`, `0`, `''`, `null`, `undefined`, and `NaN`. Everything else is truthy.
*/
toBeTruthy(): R;
/**
* Used to check that a variable is undefined.
*/
toBeUndefined(): R;
/**
* Used to check that a variable is NaN.
*/
toBeNaN(): R;
/**
* Used when you want to check that an item is in a list.
* For testing the items in the list, this uses `===`, a strict equality check.
*/
toContain(expected: unknown): R;
/**
* Used when you want to check that an item is in a list.
* For testing the items in the list, this matcher recursively checks the
* equality of all fields, rather than checking for object identity.
*/
toContainEqual(expected: unknown): R;
/**
* Used when you want to check that two objects have the same value.
* This matcher recursively checks the equality of all fields, rather than checking for object identity.
*/
toEqual(expected: unknown): R;
// /**
// * Ensures that a mock function is called.
// */
// toHaveBeenCalled(): R;
// /**
// * Ensures that a mock function is called an exact number of times.
// */
// toHaveBeenCalledTimes(expected: number): R;
// /**
// * Ensure that a mock function is called with specific arguments.
// */
// toHaveBeenCalledWith(...args: Array<unknown>): R;
// /**
// * Ensure that a mock function is called with specific arguments on an Nth call.
// */
// toHaveBeenNthCalledWith(nthCall: number, ...args: Array<unknown>): R;
// /**
// * If you have a mock function, you can use `.toHaveBeenLastCalledWith`
// * to test what arguments it was last called with.
// */
// toHaveBeenLastCalledWith(...args: Array<unknown>): R;
// /**
// * Use to test the specific value that a mock function last returned.
// * If the last call to the mock function threw an error, then this matcher will fail
// * no matter what value you provided as the expected return value.
// */
// toHaveLastReturnedWith(expected: unknown): R;
/**
* Used to check that an object has a `.length` property
* and it is set to a certain numeric value.
*/
toHaveLength(expected: number): R;
// /**
// * Use to test the specific value that a mock function returned for the nth call.
// * If the nth call to the mock function threw an error, then this matcher will fail
// * no matter what value you provided as the expected return value.
// */
// toHaveNthReturnedWith(nthCall: number, expected: unknown): R;
/**
* Use to check if property at provided reference keyPath exists for an object.
* For checking deeply nested properties in an object you may use dot notation or an array containing
* the keyPath for deep references.
*
* Optionally, you can provide a value to check if it's equal to the value present at keyPath
* on the target object. This matcher uses 'deep equality' (like `toEqual()`) and recursively checks
* the equality of all fields.
*
* @example
*
* expect(houseForSale).toHaveProperty('kitchen.area', 20);
*/
toHaveProperty(keyPath: string | Array<string>, value?: unknown): R;
// /**
// * Use to test that the mock function successfully returned (i.e., did not throw an error) at least one time
// */
// toHaveReturned(): R;
// /**
// * Use to ensure that a mock function returned successfully (i.e., did not throw an error) an exact number of times.
// * Any calls to the mock function that throw an error are not counted toward the number of times the function returned.
// */
// toHaveReturnedTimes(expected: number): R;
// /**
// * Use to ensure that a mock function returned a specific value.
// */
// toHaveReturnedWith(expected: unknown): R;
/**
* Check that a string matches a regular expression.
*/
toMatch(expected: string | RegExp): R;
/**
* Used to check that a JavaScript object matches a subset of the properties of an object
*/
toMatchObject(expected: Record<string, unknown> | Array<unknown>): R;
// /**
// * Ensure that a mock function has returned (as opposed to thrown) at least once.
// */
// toReturn(): R;
// /**
// * Ensure that a mock function has returned (as opposed to thrown) a specified number of times.
// */
// toReturnTimes(count: number): R;
// /**
// * Ensure that a mock function has returned a specified value at least once.
// */
// toReturnWith(value: unknown): R;
/**
* Use to test that objects have the same types as well as structure.
*/
toStrictEqual(expected: unknown): R;
/**
* Used to test that a function throws when it is called.
*/
toThrow(error?: unknown): R;
/**
* If you want to test that a specific error is thrown inside a function.
*/
toThrowError(error?: unknown): R;
// /**
// * This ensures that a value matches the most recent snapshot with property matchers.
// * Check out [the Snapshot Testing guide](https://jestjs.io/docs/snapshot-testing) for more information.
// */
// toMatchSnapshot<T extends {
// [P in keyof R]: unknown;
// }>(propertyMatchers: Partial<T>, snapshotName?: string): R;
// /**
// * This ensures that a value matches the most recent snapshot.
// * Check out [the Snapshot Testing guide](https://jestjs.io/docs/snapshot-testing) for more information.
// */
// toMatchSnapshot(snapshotName?: string): R;
// /**
// * This ensures that a value matches the most recent snapshot with property matchers.
// * Instead of writing the snapshot value to a .snap file, it will be written into the source code automatically.
// * Check out [the Snapshot Testing guide](https://jestjs.io/docs/snapshot-testing) for more information.
// */
// toMatchInlineSnapshot<T extends {
// [P in keyof R]: unknown;
// }>(propertyMatchers: Partial<T>, snapshot?: string): R;
// /**
// * This ensures that a value matches the most recent snapshot with property matchers.
// * Instead of writing the snapshot value to a .snap file, it will be written into the source code automatically.
// * Check out [the Snapshot Testing guide](https://jestjs.io/docs/snapshot-testing) for more information.
// */
// toMatchInlineSnapshot(snapshot?: string): R;
// /**
// * Used to test that a function throws a error matching the most recent snapshot when it is called.
// */
// toThrowErrorMatchingSnapshot(): R;
// /**
// * Used to test that a function throws a error matching the most recent snapshot when it is called.
// * Instead of writing the snapshot value to a .snap file, it will be written into the source code automatically.
// */
// toThrowErrorMatchingInlineSnapshot(snapshot?: string): R;
}
export {};

54
packages/playwright-test/types/test.d.ts vendored
View File

@ -2995,14 +2995,14 @@ export interface PlaywrightTestArgs {
export type PlaywrightTestProject<TestArgs = {}, WorkerArgs = {}> = Project<PlaywrightTestOptions & TestArgs, PlaywrightWorkerOptions & WorkerArgs>;
export type PlaywrightTestConfig<TestArgs = {}, WorkerArgs = {}> = Config<PlaywrightTestOptions & TestArgs, PlaywrightWorkerOptions & WorkerArgs>;
import type * as expectType from 'expect';
import type * as expectType from '@playwright/test/types/expect-types';
type AsymmetricMatcher = Record<string, any>;
type IfAny<T, Y, N> = 0 extends (1 & T) ? Y : N;
type ExtraMatchers<T, Type, Matchers> = T extends Type ? Matchers : IfAny<T, Matchers, {}>;
type BaseMatchers<R, T> = Pick<expectType.Matchers<R>, SupportedExpectProperties> & PlaywrightTest.Matchers<R, T>;
type BaseMatchers<R, T> = expectType.Matchers<R> & PlaywrightTest.Matchers<R, T>;
type MakeMatchers<R, T> = BaseMatchers<R, T> & {
/**
@ -3053,56 +3053,6 @@ export type Expect = {
type Awaited<T> = T extends PromiseLike<infer U> ? U : T;
/**
* Removed methods require the jest.fn() integration from Jest to spy on function calls which we don't support:
* - lastCalledWith()
* - lastReturnedWith()
* - nthCalledWith()
* - nthReturnedWith()
* - toBeCalled()
* - toBeCalledTimes()
* - toBeCalledWith()
* - toHaveBeenCalled()
* - toHaveBeenCalledTimes()
* - toHaveBeenCalledWith()
* - toHaveBeenLastCalledWith()
* - toHaveBeenNthCalledWith()
* - toHaveLastReturnedWith()
* - toHaveNthReturnedWith()
* - toHaveReturned()
* - toHaveReturnedTimes()
* - toHaveReturnedWith()
* - toReturn()
* - toReturnTimes()
* - toReturnWith()
* - toThrowErrorMatchingSnapshot()
* - toThrowErrorMatchingInlineSnapshot()
*/
type SupportedExpectProperties =
'toBe' |
'toBeCloseTo' |
'toBeDefined' |
'toBeFalsy' |
'toBeGreaterThan' |
'toBeGreaterThanOrEqual' |
'toBeInstanceOf' |
'toBeLessThan' |
'toBeLessThanOrEqual' |
'toBeNaN' |
'toBeNull' |
'toBeTruthy' |
'toBeUndefined' |
'toContain' |
'toContainEqual' |
'toEqual' |
'toHaveLength' |
'toHaveProperty' |
'toMatch' |
'toMatchObject' |
'toStrictEqual' |
'toThrow' |
'toThrowError'
// --- BEGINGLOBAL ---
declare global {
export namespace PlaywrightTest {

54
tests/config/experimental.d.ts vendored
View File

@ -19208,14 +19208,14 @@ export interface PlaywrightTestArgs {
export type PlaywrightTestProject<TestArgs = {}, WorkerArgs = {}> = Project<PlaywrightTestOptions & TestArgs, PlaywrightWorkerOptions & WorkerArgs>;
export type PlaywrightTestConfig<TestArgs = {}, WorkerArgs = {}> = Config<PlaywrightTestOptions & TestArgs, PlaywrightWorkerOptions & WorkerArgs>;
import type * as expectType from 'expect';
import type * as expectType from '@playwright/test/types/expect-types';
type AsymmetricMatcher = Record<string, any>;
type IfAny<T, Y, N> = 0 extends (1 & T) ? Y : N;
type ExtraMatchers<T, Type, Matchers> = T extends Type ? Matchers : IfAny<T, Matchers, {}>;
type BaseMatchers<R, T> = Pick<expectType.Matchers<R>, SupportedExpectProperties> & PlaywrightTest.Matchers<R, T>;
type BaseMatchers<R, T> = expectType.Matchers<R> & PlaywrightTest.Matchers<R, T>;
type MakeMatchers<R, T> = BaseMatchers<R, T> & {
/**
@ -19266,56 +19266,6 @@ export type Expect = {
type Awaited<T> = T extends PromiseLike<infer U> ? U : T;
/**
* Removed methods require the jest.fn() integration from Jest to spy on function calls which we don't support:
* - lastCalledWith()
* - lastReturnedWith()
* - nthCalledWith()
* - nthReturnedWith()
* - toBeCalled()
* - toBeCalledTimes()
* - toBeCalledWith()
* - toHaveBeenCalled()
* - toHaveBeenCalledTimes()
* - toHaveBeenCalledWith()
* - toHaveBeenLastCalledWith()
* - toHaveBeenNthCalledWith()
* - toHaveLastReturnedWith()
* - toHaveNthReturnedWith()
* - toHaveReturned()
* - toHaveReturnedTimes()
* - toHaveReturnedWith()
* - toReturn()
* - toReturnTimes()
* - toReturnWith()
* - toThrowErrorMatchingSnapshot()
* - toThrowErrorMatchingInlineSnapshot()
*/
type SupportedExpectProperties =
'toBe' |
'toBeCloseTo' |
'toBeDefined' |
'toBeFalsy' |
'toBeGreaterThan' |
'toBeGreaterThanOrEqual' |
'toBeInstanceOf' |
'toBeLessThan' |
'toBeLessThanOrEqual' |
'toBeNaN' |
'toBeNull' |
'toBeTruthy' |
'toBeUndefined' |
'toContain' |
'toContainEqual' |
'toEqual' |
'toHaveLength' |
'toHaveProperty' |
'toMatch' |
'toMatchObject' |
'toStrictEqual' |
'toThrow' |
'toThrowError'
/**
* These tests are executed in Playwright environment that launches the browser

54
utils/generate_types/overrides-test.d.ts vendored
View File

@ -296,14 +296,14 @@ export interface PlaywrightTestArgs {
export type PlaywrightTestProject<TestArgs = {}, WorkerArgs = {}> = Project<PlaywrightTestOptions & TestArgs, PlaywrightWorkerOptions & WorkerArgs>;
export type PlaywrightTestConfig<TestArgs = {}, WorkerArgs = {}> = Config<PlaywrightTestOptions & TestArgs, PlaywrightWorkerOptions & WorkerArgs>;
import type * as expectType from 'expect';
import type * as expectType from '@playwright/test/types/expect-types';
type AsymmetricMatcher = Record<string, any>;
type IfAny<T, Y, N> = 0 extends (1 & T) ? Y : N;
type ExtraMatchers<T, Type, Matchers> = T extends Type ? Matchers : IfAny<T, Matchers, {}>;
type BaseMatchers<R, T> = Pick<expectType.Matchers<R>, SupportedExpectProperties> & PlaywrightTest.Matchers<R, T>;
type BaseMatchers<R, T> = expectType.Matchers<R> & PlaywrightTest.Matchers<R, T>;
type MakeMatchers<R, T> = BaseMatchers<R, T> & {
/**
@ -354,56 +354,6 @@ export type Expect = {
type Awaited<T> = T extends PromiseLike<infer U> ? U : T;
/**
* Removed methods require the jest.fn() integration from Jest to spy on function calls which we don't support:
* - lastCalledWith()
* - lastReturnedWith()
* - nthCalledWith()
* - nthReturnedWith()
* - toBeCalled()
* - toBeCalledTimes()
* - toBeCalledWith()
* - toHaveBeenCalled()
* - toHaveBeenCalledTimes()
* - toHaveBeenCalledWith()
* - toHaveBeenLastCalledWith()
* - toHaveBeenNthCalledWith()
* - toHaveLastReturnedWith()
* - toHaveNthReturnedWith()
* - toHaveReturned()
* - toHaveReturnedTimes()
* - toHaveReturnedWith()
* - toReturn()
* - toReturnTimes()
* - toReturnWith()
* - toThrowErrorMatchingSnapshot()
* - toThrowErrorMatchingInlineSnapshot()
*/
type SupportedExpectProperties =
'toBe' |
'toBeCloseTo' |
'toBeDefined' |
'toBeFalsy' |
'toBeGreaterThan' |
'toBeGreaterThanOrEqual' |
'toBeInstanceOf' |
'toBeLessThan' |
'toBeLessThanOrEqual' |
'toBeNaN' |
'toBeNull' |
'toBeTruthy' |
'toBeUndefined' |
'toContain' |
'toContainEqual' |
'toEqual' |
'toHaveLength' |
'toHaveProperty' |
'toMatch' |
'toMatchObject' |
'toStrictEqual' |
'toThrow' |
'toThrowError'
// --- BEGINGLOBAL ---
declare global {
export namespace PlaywrightTest {