globals.d.ts

/**
 KlassiTech Automated Testing Tool
 Created by Larry Goddard
 */
/**
 Copyright © klassitech 2016 - Larry Goddard <larryg@klassitech.co.uk>

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */

// TestFramework globals
declare const shared: any;
declare const page: any;
declare const helpers: any;
declare const settings: any;

// KLASSI NOTE
// adapted from https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/cucumber/index.d.ts
// for our step-definitions only
export type StepDefinitionCode = (this: World, ...stepArgs: any[]) => any;

export interface StepDefinitionOptions {
    timeout?: number;
}

export interface StepDefinitions {
    Given(pattern: RegExp | string, options: StepDefinitionOptions, code: StepDefinitionCode): void;
    Given(pattern: RegExp | string, code: StepDefinitionCode): void;
    When(pattern: RegExp | string, options: StepDefinitionOptions, code: StepDefinitionCode): void;
    When(pattern: RegExp | string, code: StepDefinitionCode): void;
    Then(pattern: RegExp | string, options: StepDefinitionOptions, code: StepDefinitionCode): void;
    Then(pattern: RegExp | string, code: StepDefinitionCode): void;
    setDefaultTimeout(time: number): void;
}

export type HookCode = (this: World, scenario: HookScenarioResult, callback?: CallbackStepDefinition) => void;
export type GlobalHookCode = (callback?: CallbackStepDefinition) => void;

export interface Transform {
    regexp: RegExp;
    transformer(this: World, ...arg: string[]): any;
    useForSnippets?: boolean;
    preferForRegexpMatch?: boolean;
    name?: string;
    typeName?: string; // deprecated
}

export interface HookOptions {
    timeout?: number;
    tags?: any;
}

export interface Hooks {
    Before(code: HookCode): void;
    Before(options: HookOptions | string, code: HookCode): void;
    BeforeAll(code: GlobalHookCode): void;
    BeforeAll(options: HookOptions | string, code: GlobalHookCode): void;
    After(code: HookCode): void;
    After(options: HookOptions | string, code: HookCode): void;
    AfterAll(code: GlobalHookCode): void;
    AfterAll(options: HookOptions | string, code: GlobalHookCode): void;
    setDefaultTimeout(time: number): void;
    // tslint:disable-next-line ban-types
    setWorldConstructor(world: ((this: World, init: {attach: Function, parameters: {[key: string]: any}}) => void) | {}): void;
    defineParameterType(transform: Transform): void;
}

export interface StepDefinition {
    // tslint:disable-next-line ban-types
    code: Function;
    line: number;
    options: {};
    pattern: any;
    uri: string;
}

export interface Tag {
    name: string;
    line: number;
}

export interface Step {
    arguments: any;
    line: number;
    name: string;
    scenario: Scenario;
    uri: string;
    isBackground: boolean;
    keyword: string;
    keywordType: string;
}

export interface Scenario {
    feature: Feature;
    exception: Error;
    keyword: string;
    lines: number[];
    name: string;
    tags: Tag[];
    uri: string;
    line: number;
    description: string;
    steps: Step[];
}

export interface Feature {
    description: string;
    keyword: string;
    line: number;
    name: string;
    tags: Tag[];
    uri: string;
    scenarios: Scenario[];
}

// KLASSI NOTE - aside from the browser global being renamed "driver", this is exactly the same as https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/master/types/webdriverio/index.d.ts
// Type definitions for WebDriver v5
// Project: https://www.npmjs.com/package/webdriver
// Definitions by: auto generated by https://github.com/webdriverio/webdriverio
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference types="node"/>

type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

type ArgumentTypes<T> = T extends (...args: infer U) => infer R ? U : never;
type WrapWithPromise<T, R> = (...args: ArgumentTypes<T>) => Promise<R>;

declare namespace WebDriver {
    type PageLoadingStrategy = 'none' | 'eager' | 'normal';
    type ProxyTypes = 'pac' | 'noproxy' | 'autodetect' | 'system' | 'manual';
    type WebDriverLogTypes = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent';
    type LoggingPreferenceType =
        'OFF' | 'SEVERE' | 'WARNING' |
        'INFO' | 'CONFIG' | 'FINE' |
        'FINER' | 'FINEST' | 'ALL';
    type FirefoxLogLevels =
        'trace' | 'debug' | 'config' |
        'info' | 'warn' | 'error' | 'fatal';
    type Timeouts = 'script' | 'pageLoad' | 'implicit';

    interface ProxyObject {
        proxyType?: ProxyTypes;
        proxyAutoconfigUrl?: string;
        ftpProxy?: string;
        ftpProxyPort?: number;
        httpProxy?: string;
        httpProxyPort?: number;
        sslProxy?: string;
        sslProxyPort?: number;
        socksProxy?: string;
        socksProxyPort?: number;
        socksVersion?: string;
        socksUsername?: string;
        socksPassword?: string;
    }

    interface LoggingPreferences {
        browser?: LoggingPreferenceType;
        driver?: LoggingPreferenceType;
        server?: LoggingPreferenceType;
        client?: LoggingPreferenceType;
    }

    interface Cookie {
        name: string;
        value: string;
        path?: string;
        httpOnly?: boolean;
        expiry?: number;
        secure?: boolean;
    }

    interface ChromeOptions {
        args?: string[];
        binary?: string;
        extensions?: string[];
        localState?: {
            [name: string]: any;
        };
        detach?: boolean;
        debuggerAddress?: string;
        excludeSwitches?: string[];
        minidumpPath?: string;
        mobileEmulation?: {
            [name: string]: any;
        };
        perfLoggingPrefs?: {
            [name: string]: any;
        };
        windowTypes?: string[];
    }

    interface FirefoxLogObject {
        level: FirefoxLogLevels
    }

    interface FirefoxOptions {
        binary?: string,
        args?: string[],
        profile?: string,
        log?: FirefoxLogObject,
        prefs: {
            [name: string]: string | number | boolean;
        }
    }

    interface Capabilities {
        browserName?: string;
        browserVersion?: string;
        platformName?: string;
        acceptInsecureCerts?: boolean;
        pageLoadStrategy?: PageLoadingStrategy;
        proxy?: ProxyObject;
        setWindowRect?: boolean;
        timeouts?: Timeouts;
        unhandledPromptBehavior?: string;
    }

    interface DesiredCapabilities extends Capabilities {
        // Read-only capabilities
        cssSelectorsEnabled?: boolean;
        handlesAlerts?: boolean;
        version?: string;
        platform?: string;

        // Read-write capabilities
        javascriptEnabled?: boolean;
        databaseEnabled?: boolean;
        locationContextEnabled?: boolean;
        applicationCacheEnabled?: boolean;
        browserConnectionEnabled?: boolean;
        webStorageEnabled?: boolean;
        acceptSslCerts?: boolean;
        rotatable?: boolean;
        nativeEvents?: boolean;
        unexpectedAlertBehaviour?: string;
        elementScrollBehavior?: number;

        // Grid-specific
        seleniumProtocol?: string;
        maxInstances?: number;
        environment?: string;

        // Selenium RC (1.0) only
        commandLineFlags?: string;
        executablePath?: string;
        timeoutInSeconds?: number;
        onlyProxySeleniumTraffic?: boolean;
        avoidProxy?: boolean;
        proxyEverything?: boolean;
        proxyRequired?: boolean;
        browserSideLog?: boolean;
        optionsSet?: boolean;
        singleWindow?: boolean;
        dontInjectRegex?: RegExp;
        userJSInjection?: boolean;
        userExtensions?: string;

        // RemoteWebDriver specific
        'webdriver.remote.sessionid'?: string;
        'webdriver.remote.quietExceptions'?: boolean;

        // Selenese-Backed-WebDriver specific
        'selenium.server.url'?: string;

        loggingPrefs?: {
            browser?: LoggingPreferences;
            driver?: LoggingPreferences;
            server?: LoggingPreferences;
            client?: LoggingPreferences;
        };

        // Firefox
        firefox_binary?: string;
        firefoxProfileTemplate?: string;
        captureNetworkTraffic?: boolean;
        addCustomRequestHeaders?: boolean;
        trustAllSSLCertificates?: boolean;
        changeMaxConnections?: boolean;
        profile?: string;
        pageLoadingStrategy?: string;
        'moz:firefoxOptions'?: FirefoxOptions;

        // IE specific
        'ie.forceCreateProcessApi'?: boolean;
        'ie.browserCommandLineSwitches'?: string;
        'ie.usePerProcessProxy'?: boolean;
        'ie.ensureCleanSession'?: boolean;
        'ie.setProxyByServer'?: boolean;
        ignoreProtectedModeSettings?: boolean;
        ignoreZoomSetting?: boolean;
        initialBrowserUrl?: string;
        enablePersistentHover?: boolean;
        enableElementCacheCleanup?: boolean;
        requireWindowFocus?: boolean;
        browserAttachTimeout?: number;
        logFile?: string;
        logLevel?: string;
        host?: string;
        extractPath?: string;
        silent?: string;
        killProcessesByName?: boolean;

        // Safari specific
        'safari.options'?: {
            [name: string]: any;
        };

        cleanSession?: boolean;

        // Chrome specific
        chromeOptions?: ChromeOptions;
        'goog:chromeOptions'?: ChromeOptions;
        mobileEmulationEnabled?: boolean;

        perfLoggingPrefs?: {
            enableNetwork?: boolean;
            enablePage?: boolean;
            enableTimeline?: boolean;
            tracingCategories?: boolean;
            bufferUsageReportingInterval?: boolean;
        };

        // wdio-sauce-service specific
        build?: string;

        // Appium
        deviceName?: string;
        platformVersion?: string;
        app?: string;
        udid?: string;
    }

    interface Options {
        protocol?: string;
        hostname?: string;
        port?: number;
        path?: string;
        queryParams?: {
            [name: string]: string;
        },
        capabilities?: DesiredCapabilities;
        logLevel?: WebDriverLogTypes;
        logOutput?: string | NodeJS.WritableStream
        connectionRetryTimeout?: number;
        connectionRetryCount?: number;
        user?: string;
        key?: string;
    }

    function newSession(
        options?: Options,
        modifier?: (...args: any[]) => any,
        proto?: object,
        commandWrapper?: (commandName: string, fn: (...args: any[]) => any) => any
    ): Promise<Client>;

    interface ClientOptions {
        capabilities: DesiredCapabilities;
        isW3C: boolean;
        isAndroid: boolean;
        isMobile: boolean;
        isIOS: boolean;
        sessionId: string;
    }

    // generated typings
    // ... insert here ...

    interface ClientAsync extends AsyncClient {}
}

type AsyncClient = {
    [K in keyof WebDriver.Client]: WrapWithPromise<WebDriver.Client[K], ReturnType<WebDriver.Client[K]>>
}

declare module "webdriver" {
    export = WebDriver;
}


/// <reference types="node"/>
/// <reference types="webdriver"/>

declare namespace WebdriverIO {
    type LocationParam = 'x' | 'y';

    interface LocationReturn {
        x: number,
        y: number
    }

    type SizeParam = 'width' | 'height';

    interface SizeReturn {
        width: number,
        height: number
    }

    interface Cookie {
        name: string,
        value: string,
        domain?: string,
        path?: string,
        expiry?: number,
        isSecure?: boolean,
        isHttpOnly?: boolean
    }

    interface CSSProperty {
        property: string,
        value: any,
        parsed?: {
            // other
            unit?: string,
            // font-family
            value?: any,
            string: string,
            // color
            hex?: string,
            alpha?: number,
            type?: string,
            rgba?: string
        }
    }

    interface Options {
        runner?: string,
        specs?: string[],
        exclude?: string[],
        suites?: object,
        maxInstances?: number,
        maxInstancesPerCapability?: number,
        capabilities?: WebDriver.DesiredCapabilities | WebDriver.DesiredCapabilities[],
        outputDir?: string,
        baseUrl?: string,
        bail?: number,
        waitforTimeout?: number,
        waitforInterval?: number,
        framework?: string,
        mochaOpts?: object,
        jasmineNodeOpts?: object,
        reporters?: (string | object)[],
        services?: (string | object)[],
        execArgv?: string[]
    }

    interface MultiRemoteOptions {
        [capabilityName: string]: Options;
    }

    interface Suite {}
    interface Test {}

    interface Results {
        finished: number,
        passed: number,
        failed: number
    }

    interface Hooks {
        onPrepare?(
            config: Config,
            capabilities: WebDriver.DesiredCapabilities
        ): void;

        onComplete?(exitCode: number, config: Config, capabilities: WebDriver.DesiredCapabilities, results: Results): void;

        onReload?(oldSessionId: string, newSessionId: string): void;

        before?(
            capabilities: WebDriver.DesiredCapabilities,
            specs: string[]
        ): void;

        beforeCommand?(
            commandName: string,
            args: any[]
        ): void;

        beforeHook?(): void;

        beforeSession?(
            config: Config,
            capabilities: WebDriver.DesiredCapabilities,
            specs: string[]
        ): void;

        beforeSuite?(suite: Suite): void;
        beforeTest?(test: Test): void;
        afterHook?(): void;

        after?(
            result: number,
            capabilities: WebDriver.DesiredCapabilities,
            specs: string[]
        ): void;

        afterCommand?(
            commandName: string,
            args: any[],
            result: any,
            error?: Error
        ): void;

        afterSession?(
            config: Config,
            capabilities: WebDriver.DesiredCapabilities,
            specs: string[]
        ): void;

        afterSuite?(suite: Suite): void;
        afterTest?(test: Test): void;

        // cucumber specific hooks
        beforeFeature?(feature: string): void;
        beforeScenario?(scenario: string): void;
        beforeStep?(step: string): void;
        afterFeature?(feature: string): void;
        afterScenario?(scenario: any): void;
        afterStep?(stepResult: any): void;
    }

    type ActionTypes = 'press' | 'longPress' | 'tap' | 'moveTo' | 'wait' | 'release';
    interface TouchAction {
        action: ActionTypes,
        x?: number,
        y?: number,
        element?: Element
    }
    type TouchActions = string | TouchAction | TouchAction[];

    interface Element {
        addCommand(
            name: string,
            func: Function
        ): void;
        // ... element commands ...
    }

    type Execute = <T>(script: string | ((...arguments: any[]) => T), ...arguments: any[]) => T;
    type ExecuteAsync = (script: string | ((...arguments: any[]) => any), ...arguments: any[]) => any;
    type Call = <T>(callback: Function) => T;
    interface Timeouts {
        implicit?: number,
        pageLoad?: number,
        script?: number
    }

    interface Browser {
        addCommand(
            name: string,
            func: Function,
            attachToElement?: boolean
        ): void;
        execute: Execute;
        executeAsync: ExecuteAsync;
        call: Call;
        options: Options;
        waitUntil(
            condition: () => boolean,
            timeout?: number,
            timeoutMsg?: string,
            interval?: number
        ): void
        // ... browser commands ...
    }

    interface Config extends Options, Omit<WebDriver.Options, "capabilities">, Hooks {}
}