testplane
Version:
Tests framework based on mocha and wdio
186 lines (185 loc) • 9.49 kB
TypeScript
/// <reference types="node" />
import type { Browser as PuppeteerBrowser } from "@puppeteer/browsers";
import type { EventEmitter } from "events";
import type { AssertViewCommand, AssertViewElementCommand } from "./commands/types";
import type { BrowserConfig } from "./../config/browser-config";
import type { ExecutionThreadCtx, ExecutionThreadToolCtx } from "../types";
import type { MoveCursorToCommand } from "./commands/moveCursorTo";
import type { OpenAndWaitCommand } from "./commands/openAndWait";
import type { Callstack } from "./history/callstack";
import type { Test, Hook } from "../test-reader/test-object";
import type { CaptureSnapshotOptions, CaptureSnapshotResult } from "./commands/captureDomSnapshot";
import type { Options } from "@testplane/wdio-types";
import type { SaveStateData } from "./commands/saveState";
import type { StateOpts } from "../config/types";
import type { GetStateOptions } from "./commands/getState";
import type { RestoreStateOptions } from "./commands/restoreState";
import type { WaitForStaticToLoadResult } from "./commands/waitForStaticToLoad";
import type { CDP } from "./cdp";
export declare const BrowserName: {
readonly CHROME: PuppeteerBrowser.CHROME;
readonly CHROMIUM: PuppeteerBrowser.CHROMIUM;
readonly CHROMEHEADLESSSHELL: PuppeteerBrowser.CHROMEHEADLESSSHELL;
readonly FIREFOX: PuppeteerBrowser.FIREFOX;
readonly SAFARI: "safari";
readonly EDGE: "MicrosoftEdge";
};
export type W3CBrowserName = Exclude<(typeof BrowserName)[keyof typeof BrowserName], typeof BrowserName.CHROMIUM>;
export interface BrowserMeta {
pid: number;
browserVersion: string;
[name: string]: unknown;
}
export interface Browser {
publicAPI: WebdriverIO.Browser;
config: BrowserConfig;
state: Record<string, unknown>;
applyState: (state: Record<string, unknown>) => void;
callstackHistory: Callstack;
customCommands: {
name: string;
elementScope: boolean;
}[];
}
export interface SessionOptions {
sessionId: string;
sessionCaps?: WebdriverIO.Capabilities;
sessionOpts?: Options.WebdriverIO & {
capabilities: WebdriverIO.Capabilities;
};
driverPid?: number;
}
type FunctionProperties<T> = Exclude<{
[K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
}[keyof T], undefined>;
type EventEmitterMethod = FunctionProperties<EventEmitter>;
declare global {
namespace WebdriverIO {
type BrowserCommand = Exclude<FunctionProperties<WebdriverIO.Browser>, EventEmitterMethod>;
type ElementCommand = Exclude<FunctionProperties<WebdriverIO.Element>, EventEmitterMethod>;
type OverwriteCommandFn<ThisArg, Fn extends (...args: any) => any> = (this: ThisArg, origCommand: OmitThisParameter<Fn>, ...args: Parameters<Fn>) => ReturnType<Fn>;
interface Browser {
getMeta(this: WebdriverIO.Browser): Promise<BrowserMeta>;
getMeta(this: WebdriverIO.Browser, key: string): Promise<unknown>;
setMeta(this: WebdriverIO.Browser, key: string, value: unknown): Promise<void>;
addTag(this: WebdriverIO.Browser, tag: string | string[]): Promise<void>;
extendOptions(this: WebdriverIO.Browser, opts: {
[name: string]: unknown;
}): Promise<void>;
getConfig(this: WebdriverIO.Browser): Promise<BrowserConfig>;
saveState(options?: StateOpts): Promise<SaveStateData>;
restoreState(options?: RestoreStateOptions): Promise<void>;
getState(options?: GetStateOptions): Promise<SaveStateData | null>;
overwriteCommand<CommandName extends BrowserCommand>(name: CommandName, func: OverwriteCommandFn<WebdriverIO.Browser, WebdriverIO.Browser[CommandName]>, attachToElement?: false, proto?: Record<string, any>, // eslint-disable-line @typescript-eslint/no-explicit-any
instances?: Record<string, WebdriverIO.Browser | WebdriverIO.MultiRemoteBrowser>): void;
overwriteCommand<CommandName extends ElementCommand>(name: CommandName, func: OverwriteCommandFn<WebdriverIO.Element, WebdriverIO.Element[CommandName]>, attachToElement: true, proto?: Record<string, any>, // eslint-disable-line @typescript-eslint/no-explicit-any
instances?: Record<string, WebdriverIO.Browser | WebdriverIO.MultiRemoteBrowser>): void;
/**
* Takes a screenshot of the passed selector and compares the received screenshot with the reference.
*
* @remarks
* For more details, see {@link https://github.com/gemini-testing/testplane#assertview documentation}.
*
* @example
* ```ts
*
* it('some test', async function() {
* await this.browser.url('some/url');
* await this.browser.assertView('plain', '.button', {
* ignoreElements: ['.link'],
* tolerance: 2.3,
* antialiasingTolerance: 4,
* allowViewportOverflow: true,
* captureElementFromTop: true,
* compositeImage: true,
* screenshotDelay: 600,
* selectorToScroll: '.modal'
* });
*});
* ```
*
* @param state state name, should be unique within one test
* @param selectors DOM-node selector that you need to capture
* @param opts additional options, currently available:
* "ignoreElements", "tolerance", "antialiasingTolerance", "allowViewportOverflow", "captureElementFromTop",
* "compositeImage", "screenshotDelay", "selectorToScroll"
*/
assertView: AssertViewCommand;
/**
* Command that allows to add human-readable description for commands in history
*
* @remarks
* For more details, see {@link https://github.com/gemini-testing/testplane#runstep documentation}
*
* @example
* ```ts
* it('some test', async function () {
* await this.browser.runStep('step name', async () => {
* await this.browser.url('some/url');
* ...
* });
* })
* ```
*
* @param stepName step name
* @param stepCb step callback
* @returns {Promise<T>} value, returned by `stepCb`
*/
runStep<T = unknown>(this: WebdriverIO.Browser, stepName: string, stepCb: () => Promise<T> | T): Promise<T>;
executionContext: (Test | Hook) & {
testplaneCtx: ExecutionThreadToolCtx;
/**
* @deprecated Use `testplaneCtx` instead
*/
hermioneCtx: ExecutionThreadToolCtx;
ctx: ExecutionThreadCtx;
};
openAndWait: OpenAndWaitCommand;
switchToRepl: (this: WebdriverIO.Browser, ctx?: Record<string, unknown>) => Promise<void>;
clearSession: (this: WebdriverIO.Browser) => Promise<void>;
waitForStaticToLoad: (this: WebdriverIO.Browser, opts?: {
timeout?: number;
interval?: number;
}) => Promise<WaitForStaticToLoadResult>;
unstable_captureDomSnapshot(this: WebdriverIO.Browser, options?: Partial<CaptureSnapshotOptions>): Promise<CaptureSnapshotResult>;
unstable_captureDomSnapshot(this: WebdriverIO.Browser, selector: string, options?: Partial<CaptureSnapshotOptions>): Promise<CaptureSnapshotResult>;
unstable_getCdp(this: WebdriverIO.Browser): Promise<CDP | null>;
}
interface Element {
/**
* Takes a screenshot of the element and compares the received screenshot with the reference.
*
* @remarks
* For more details, see {@link https://github.com/gemini-testing/testplane#assertview documentation}.
*
* @example
* ```ts
*
* it('some test', async function() {
* await this.browser.url('some/url');
* const button = await this.browser.$('.button');
* await button.assertView('plain', {
* ignoreElements: ['.link'],
* tolerance: 2.3,
* antialiasingTolerance: 4,
* allowViewportOverflow: true,
* captureElementFromTop: true,
* compositeImage: true,
* screenshotDelay: 600,
* selectorToScroll: '.modal'
* });
*});
* ```
*
* @param state state name, should be unique within one test
* @param opts additional options, currently available:
* "ignoreElements", "tolerance", "antialiasingTolerance", "allowViewportOverflow", "captureElementFromTop",
* "compositeImage", "screenshotDelay", "selectorToScroll"
*/
assertView: AssertViewElementCommand;
moveCursorTo: MoveCursorToCommand;
unstable_captureDomSnapshot(this: WebdriverIO.Element, options?: Partial<CaptureSnapshotOptions>): Promise<CaptureSnapshotResult>;
}
}
}
export {};