@appium/driver-test-support 0.2.0 → 0.2.1

package/build/lib/e2e-suite.d.ts

@@ -11,32 +11,282 @@ export function createSessionHelpers<CommandData = unknown, ResponseData = any>(
  * Creates E2E test suites for a driver.
  * @template {Driver} P
  * @param {DriverClass<P>} DriverClass
- * @param {AppiumW3CCapabilities} [defaultCaps]
+ * @param {Partial<BaseNSCapabilities>} [defaultCaps]
  */
-export function driverE2ETestSuite<P extends import("@appium/types").Driver>(DriverClass: DriverClass<P>, defaultCaps?: Partial<import("@wdio/types/build/Capabilities").Capabilities & import("@wdio/types/build/Capabilities").AppiumW3CCapabilities & {
-    [x: `${string}:${string}`]: any;
-}> | undefined): void;
+export function driverE2ETestSuite<P extends import("@appium/types").Driver<{
+    readonly platformName: {
+        readonly presence: true;
+        readonly isString: true;
+    };
+    readonly app: {
+        readonly isString: true;
+    };
+    readonly deviceName: {
+        readonly isString: true;
+    };
+    readonly platformVersion: {
+        readonly isString: true;
+    };
+    readonly newCommandTimeout: {
+        readonly isNumber: true;
+    };
+    readonly automationName: {
+        readonly isString: true;
+    };
+    readonly autoLaunch: {
+        readonly isBoolean: true;
+    };
+    readonly udid: {
+        readonly isString: true;
+    };
+    readonly orientation: {
+        readonly inclusion: readonly ["LANDSCAPE", "PORTRAIT"];
+    };
+    readonly autoWebview: {
+        readonly isBoolean: true;
+    };
+    readonly noReset: {
+        readonly isBoolean: true;
+    };
+    readonly fullReset: {
+        readonly isBoolean: true;
+    };
+    readonly language: {
+        readonly isString: true;
+    };
+    readonly locale: {
+        readonly isString: true;
+    };
+    readonly eventTimings: {
+        readonly isBoolean: true;
+    };
+    readonly printPageSourceOnFindFailure: {
+        readonly isBoolean: true;
+    };
+}, import("@appium/types").StringRecord>>(DriverClass: DriverClass<P>, defaultCaps?: Partial<import("@appium/types").CapsToNSCaps<import("@appium/types").ConstraintsToCaps<{
+    readonly platformName: {
+        readonly presence: true;
+        readonly isString: true;
+    };
+    readonly app: {
+        readonly isString: true;
+    };
+    readonly deviceName: {
+        readonly isString: true;
+    };
+    readonly platformVersion: {
+        readonly isString: true;
+    };
+    readonly newCommandTimeout: {
+        readonly isNumber: true;
+    };
+    readonly automationName: {
+        readonly isString: true;
+    };
+    readonly autoLaunch: {
+        readonly isBoolean: true;
+    };
+    readonly udid: {
+        readonly isString: true;
+    };
+    readonly orientation: {
+        readonly inclusion: readonly ["LANDSCAPE", "PORTRAIT"];
+    };
+    readonly autoWebview: {
+        readonly isBoolean: true;
+    };
+    readonly noReset: {
+        readonly isBoolean: true;
+    };
+    readonly fullReset: {
+        readonly isBoolean: true;
+    };
+    readonly language: {
+        readonly isString: true;
+    };
+    readonly locale: {
+        readonly isString: true;
+    };
+    readonly eventTimings: {
+        readonly isBoolean: true;
+    };
+    readonly printPageSourceOnFindFailure: {
+        readonly isBoolean: true;
+    };
+}>, "appium">> | undefined): void;
 /**
  * A {@linkcode DriverClass }, except using the base {@linkcode Driver } type instead of `ExternalDriver`.
  * This allows the suite to work for `BaseDriver`.
  */
-export type DriverClass<P extends import("@appium/types").Driver> = import('@appium/types').DriverClass<P>;
-export type Capabilities = import('@appium/types').Capabilities;
+export type DriverClass<P extends import("@appium/types").Driver<{
+    readonly platformName: {
+        readonly presence: true;
+        readonly isString: true;
+    };
+    readonly app: {
+        readonly isString: true;
+    };
+    readonly deviceName: {
+        readonly isString: true;
+    };
+    readonly platformVersion: {
+        readonly isString: true;
+    };
+    readonly newCommandTimeout: {
+        readonly isNumber: true;
+    };
+    readonly automationName: {
+        readonly isString: true;
+    };
+    readonly autoLaunch: {
+        readonly isBoolean: true;
+    };
+    readonly udid: {
+        readonly isString: true;
+    };
+    readonly orientation: {
+        readonly inclusion: readonly ["LANDSCAPE", "PORTRAIT"];
+    };
+    readonly autoWebview: {
+        readonly isBoolean: true;
+    };
+    readonly noReset: {
+        readonly isBoolean: true;
+    };
+    readonly fullReset: {
+        readonly isBoolean: true;
+    };
+    readonly language: {
+        readonly isString: true;
+    };
+    readonly locale: {
+        readonly isString: true;
+    };
+    readonly eventTimings: {
+        readonly isBoolean: true;
+    };
+    readonly printPageSourceOnFindFailure: {
+        readonly isBoolean: true;
+    };
+}, import("@appium/types").StringRecord>> = import('@appium/types').DriverClass<P>;
 export type Driver = import('@appium/types').Driver;
+export type Constraints = import('@appium/types').Constraints;
 export type DriverStatic = import('@appium/types').DriverStatic;
-export type AppiumW3CCapabilities = import('@appium/types').AppiumW3CCapabilities;
+export type StringRecord = import('@appium/types').StringRecord;
+export type BaseDriverCapConstraints = import('@appium/types').BaseDriverCapConstraints;
+export type BaseNSCapabilities = import('@appium/types').BaseNSCapabilities;
 export type AxiosRequestConfig = import('axios').AxiosRequestConfig;
 export type SingularSessionData = import('@appium/types').SingularSessionData;
 export type AxiosResponse<T, D> = import('axios').AxiosResponse<T, D>;
-export type NewSessionData = {
-    capabilities: import('type-fest').RequireAtLeastOne<import('@appium/types').W3CCapabilities, 'firstMatch' | 'alwaysMatch'>;
+export type NewSessionData<C extends Readonly<Record<string, import("@appium/types").Constraint>> = {
+    readonly platformName: {
+        readonly presence: true;
+        readonly isString: true;
+    };
+    readonly app: {
+        readonly isString: true;
+    };
+    readonly deviceName: {
+        readonly isString: true;
+    };
+    readonly platformVersion: {
+        readonly isString: true;
+    };
+    readonly newCommandTimeout: {
+        readonly isNumber: true;
+    };
+    readonly automationName: {
+        readonly isString: true;
+    };
+    readonly autoLaunch: {
+        readonly isBoolean: true;
+    };
+    readonly udid: {
+        readonly isString: true;
+    };
+    readonly orientation: {
+        readonly inclusion: readonly ["LANDSCAPE", "PORTRAIT"];
+    };
+    readonly autoWebview: {
+        readonly isBoolean: true;
+    };
+    readonly noReset: {
+        readonly isBoolean: true;
+    };
+    readonly fullReset: {
+        readonly isBoolean: true;
+    };
+    readonly language: {
+        readonly isString: true;
+    };
+    readonly locale: {
+        readonly isString: true;
+    };
+    readonly eventTimings: {
+        readonly isBoolean: true;
+    };
+    readonly printPageSourceOnFindFailure: {
+        readonly isBoolean: true;
+    };
+}, Extra extends void | import("@appium/types").StringRecord = void> = {
+    capabilities: import('type-fest').RequireAtLeastOne<import('@appium/types').W3CCapabilities<C, Extra>, 'firstMatch' | 'alwaysMatch'>;
 };
-export type NewSessionResponse = {
+export type NewSessionResponse<C extends Readonly<Record<string, import("@appium/types").Constraint>> = {
+    readonly platformName: {
+        readonly presence: true;
+        readonly isString: true;
+    };
+    readonly app: {
+        readonly isString: true;
+    };
+    readonly deviceName: {
+        readonly isString: true;
+    };
+    readonly platformVersion: {
+        readonly isString: true;
+    };
+    readonly newCommandTimeout: {
+        readonly isNumber: true;
+    };
+    readonly automationName: {
+        readonly isString: true;
+    };
+    readonly autoLaunch: {
+        readonly isBoolean: true;
+    };
+    readonly udid: {
+        readonly isString: true;
+    };
+    readonly orientation: {
+        readonly inclusion: readonly ["LANDSCAPE", "PORTRAIT"];
+    };
+    readonly autoWebview: {
+        readonly isBoolean: true;
+    };
+    readonly noReset: {
+        readonly isBoolean: true;
+    };
+    readonly fullReset: {
+        readonly isBoolean: true;
+    };
+    readonly language: {
+        readonly isString: true;
+    };
+    readonly locale: {
+        readonly isString: true;
+    };
+    readonly eventTimings: {
+        readonly isBoolean: true;
+    };
+    readonly printPageSourceOnFindFailure: {
+        readonly isBoolean: true;
+    };
+}, Extra extends void | import("@appium/types").StringRecord = void> = {
     /**
      * ,
      */
     sessionId: string;
-    capabilities: import('@appium/types').Capabilities;
+    capabilities: import('@appium/types').Capabilities<C, Extra>;
 };
 /**
  * Some E2E helpers for making requests and managing sessions

package/build/lib/e2e-suite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"e2e-suite.d.ts","sourceRoot":"","sources":["../../lib/e2e-suite.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,sFAJW,MAAM,2EAmFhB;AAED;;;;;GAKG;AACH;;sBAyTC;;;;;oEAMY,OAAO,eAAe,EAAE,WAAW,CAAC,CAAC,CAAC;2BAItC,OAAO,eAAe,EAAE,YAAY;qBACpC,OAAO,eAAe,EAAE,MAAM;2BAC9B,OAAO,eAAe,EAAE,YAAY;oCACpC,OAAO,eAAe,EAAE,qBAAqB;iCAC7C,OAAO,OAAO,EAAE,kBAAkB;kCAClC,OAAO,eAAe,EAAE,mBAAmB;kCAK3C,OAAO,OAAO,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC;;kBAKlC,OAAO,WAAW,EAAE,iBAAiB,CAAC,OAAO,eAAe,EAAE,eAAe,EAAE,YAAY,GAAC,aAAa,CAAC;;;;;;eAK1G,MAAM;kBACN,OAAO,eAAe,EAAE,YAAY;;;;;;;;;;mBASpC,MAAM;;;;yBACC,cAAc,WAAW,kBAAkB,KAAK,QAAQ,kBAAkB,CAAC;;;;4BACtE,MAAM,KAAK,QAAQ,cAAc;QAAC,KAAK,EAAE;YAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAC,QAAC;KAAC,EAAE;QAAC,cAAc,EAAE,IAAI,CAAA;KAAC,CAAC,CAAC;;;;4BACrF,MAAM,KAAK,QAAQ,mBAAmB,CAAC;;;;6BACvC,MAAM,WAAW,MAAM,SAAS,WAAW,WAAW,kBAAkB,KAAK,QAAQ,YAAY,CAAC;;;;qCACzF,MAAM,mBAAmB,MAAM,GAAC,kBAAkB,WAAW,kBAAkB,KAAK,QAAQ,YAAY,CAAC"}
+{"version":3,"file":"e2e-suite.d.ts","sourceRoot":"","sources":["../../lib/e2e-suite.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,sFAJW,MAAM,2EAmFhB;AAED;;;;;GAKG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAyTC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAMY,OAAO,eAAe,EAAE,WAAW,CAAC,CAAC,CAAC;qBAItC,OAAO,eAAe,EAAE,MAAM;0BAC9B,OAAO,eAAe,EAAE,WAAW;2BACnC,OAAO,eAAe,EAAE,YAAY;2BACpC,OAAO,eAAe,EAAE,YAAY;uCACpC,OAAO,eAAe,EAAE,wBAAwB;iCAChD,OAAO,eAAe,EAAE,kBAAkB;iCAC1C,OAAO,OAAO,EAAE,kBAAkB;kCAClC,OAAO,eAAe,EAAE,mBAAmB;kCAK3C,OAAO,OAAO,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAOlC,OAAO,WAAW,EAAE,iBAAiB,CAAC,OAAO,eAAe,EAAE,eAAe,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,YAAY,GAAC,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAOpH,MAAM;kBACN,OAAO,eAAe,EAAE,YAAY,CAAC,CAAC,EAAE,KAAK,CAAC;;;;;;;;;;mBAS9C,MAAM;;;;yBACC,cAAc,WAAW,kBAAkB,KAAK,QAAQ,kBAAkB,CAAC;;;;4BACtE,MAAM,KAAK,QAAQ,cAAc;QAAC,KAAK,EAAE;YAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAC,QAAC;KAAC,EAAE;QAAC,cAAc,EAAE,IAAI,CAAA;KAAC,CAAC,CAAC;;;;4BACrF,MAAM,KAAK,QAAQ,mBAAmB,CAAC;;;;6BACvC,MAAM,WAAW,MAAM,SAAS,WAAW,WAAW,kBAAkB,KAAK,QAAQ,YAAY,CAAC;;;;qCACzF,MAAM,mBAAmB,MAAM,GAAC,kBAAkB,WAAW,kBAAkB,KAAK,QAAQ,YAAY,CAAC"}

package/build/lib/e2e-suite.js

@@ -1,7 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -24,6 +22,8 @@ var _chai = _interopRequireDefault(require("chai"));
 
 var _sinon = _interopRequireDefault(require("sinon"));
 
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 const should = _chai.default.should();
 
 function createSessionHelpers(port, address = _helpers.TEST_HOST) {
@@ -98,8 +98,7 @@ function driverE2ETestSuite(DriverClass, defaultCaps = {}) {
     let postCommand;
     before(async function () {
       port = port ?? (await (0, _helpers.getTestPort)());
-      defaultCaps = { ...defaultCaps,
-        'appium:port': port
+      defaultCaps = { ...defaultCaps
       };
       d = new DriverClass({
         port,
@@ -386,4 +385,4 @@ function driverE2ETestSuite(DriverClass, defaultCaps = {}) {
     });
   });
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["should","chai","createSessionHelpers","port","address","TEST_HOST","createAppiumTestURL","createAppiumURL","createSessionURL","_","newSessionURL","postCommand","sessionId","cmdName","data","config","url","response","axios","post","value","getCommand","sessionIdOrCmdName","cmdNameOrConfig","isString","validateStatus","startSession","defaultsDeep","capabilities","alwaysMatch","firstMatch","endSession","delete","getSession","driverE2ETestSuite","DriverClass","defaultCaps","className","name","describe","baseServer","d","before","getTestPort","server","routeConfiguringFunction","hostname","cliArgs","after","close","it","sessionIds","times","headers","simple","resolveWithFullResponse","push","uniq","length","equal","status","reqs","map","B","all","exist","platformName","deviceName","skip","originalFindElement","originalFindElements","startTimeoutSession","timeout","caps","cloneDeep","findElement","bind","findElements","delay","newSession","newCommandTimeoutMs","be","above","using","error","resp","start","Date","now","eql","not","noCommandTimer","settings","DeviceSettings","ignoreUnimportantViews","getSettings","false","update","rejected","rejectedWith","sandbox","beforeEach","sinon","createSandbox","afterEach","restore","stub","callsFake","reqPromise","shutdownEventPromise","resolve","reject","setTimeout","Error","onUnexpectedShutdown","startUnexpectedShutdown","message","contain","session","res","events","newSessionRequested","newSessionStarted","a"],"sources":["../../lib/e2e-suite.js"],"sourcesContent":["import _ from 'lodash';\nimport {server, routeConfiguringFunction, DeviceSettings} from 'appium/driver';\nimport axios from 'axios';\nimport B from 'bluebird';\nimport {TEST_HOST, getTestPort, createAppiumURL} from './helpers';\nimport chai from 'chai';\nimport sinon from 'sinon';\n\nconst should = chai.should();\n\n/**\n * Creates some helper functions for E2E tests to manage sessions.\n * @template [CommandData=unknown]\n * @template [ResponseData=any]\n * @param {number} port - Port on which the server is running. Typically this will be retrieved via `get-port` beforehand\n * @param {string} [address] - Address/host on which the server is running. Defaults to {@linkcode TEST_HOST}\n * @returns {SessionHelpers<CommandData, ResponseData>}\n */\nexport function createSessionHelpers(port, address = TEST_HOST) {\n  const createAppiumTestURL =\n    /** @type {import('lodash').CurriedFunction2<string,string,string>} */ (\n      createAppiumURL(address, port)\n    );\n\n  const createSessionURL = createAppiumTestURL(_, '');\n  const newSessionURL = createAppiumTestURL('', 'session');\n  return /** @type {SessionHelpers<CommandData, ResponseData>} */ ({\n    newSessionURL,\n    createAppiumTestURL,\n    /**\n     *\n     * @param {string} sessionId\n     * @param {string} cmdName\n     * @param {any} [data]\n     * @param {AxiosRequestConfig} [config]\n     * @returns {Promise<any>}\n     */\n    postCommand: async (sessionId, cmdName, data = {}, config = {}) => {\n      const url = createAppiumTestURL(sessionId, cmdName);\n      const response = await axios.post(url, data, config);\n      return response.data?.value;\n    },\n    /**\n     *\n     * @param {string} sessionIdOrCmdName\n     * @param {string|AxiosRequestConfig} cmdNameOrConfig\n     * @param {AxiosRequestConfig} [config]\n     * @returns {Promise<any>}\n     */\n    getCommand: async (sessionIdOrCmdName, cmdNameOrConfig, config = {}) => {\n      if (!_.isString(cmdNameOrConfig)) {\n        config = cmdNameOrConfig;\n        cmdNameOrConfig = sessionIdOrCmdName;\n        sessionIdOrCmdName = '';\n      }\n      const response = await axios({\n        url: createAppiumTestURL(sessionIdOrCmdName, cmdNameOrConfig),\n        validateStatus: null,\n        ...config,\n      });\n      return response.data?.value;\n    },\n    /**\n     *\n     * @param {NewSessionData} data\n     * @param {AxiosRequestConfig} [config]\n     */\n    startSession: async (data, config = {}) => {\n      data = _.defaultsDeep(data, {\n        capabilities: {\n          alwaysMatch: {},\n          firstMatch: [{}],\n        },\n      });\n      const response = await axios.post(newSessionURL, data, config);\n      return response.data?.value;\n    },\n    /**\n     *\n     * @param {string} sessionId\n     */\n    endSession: async (sessionId) =>\n      await axios.delete(createSessionURL(sessionId), {\n        validateStatus: null,\n      }),\n    /**\n     * @param {string} sessionId\n     * @returns {Promise<any>}\n     */\n    getSession: async (sessionId) => {\n      const response = await axios({\n        url: createSessionURL(sessionId),\n        validateStatus: null,\n      });\n      return response.data?.value;\n    },\n  });\n}\n\n/**\n * Creates E2E test suites for a driver.\n * @template {Driver} P\n * @param {DriverClass<P>} DriverClass\n * @param {AppiumW3CCapabilities} [defaultCaps]\n */\nexport function driverE2ETestSuite(DriverClass, defaultCaps = {}) {\n  let address = defaultCaps['appium:address'] ?? TEST_HOST;\n  let port = defaultCaps['appium:port'];\n  const className = DriverClass.name || '(unknown driver)';\n\n  describe(`BaseDriver E2E (as ${className})`, function () {\n    let baseServer;\n    /** @type {P} */\n    let d;\n    /**\n     * This URL creates a new session\n     * @type {string}\n     **/\n    let newSessionURL;\n\n    /** @type {SessionHelpers['startSession']} */\n    let startSession;\n    /** @type {SessionHelpers['getSession']} */\n    let getSession;\n    /** @type {SessionHelpers['endSession']} */\n    let endSession;\n    /** @type {SessionHelpers['getCommand']} */\n    let getCommand;\n    /** @type {SessionHelpers['postCommand']} */\n    let postCommand;\n    before(async function () {\n      port = port ?? (await getTestPort());\n      defaultCaps = {...defaultCaps, 'appium:port': port};\n      d = new DriverClass({port, address});\n      baseServer = await server({\n        routeConfiguringFunction: routeConfiguringFunction(d),\n        port,\n        hostname: address,\n        // @ts-expect-error\n        cliArgs: {},\n      });\n      ({startSession, getSession, endSession, newSessionURL, getCommand, postCommand} =\n        createSessionHelpers(port, address));\n    });\n\n    after(async function () {\n      await baseServer.close();\n    });\n\n    describe('session handling', function () {\n      it('should handle idempotency while creating sessions', async function () {\n        const sessionIds = [];\n        let times = 0;\n        do {\n          const {sessionId} = await startSession(\n            {\n              capabilities: {alwaysMatch: defaultCaps},\n            },\n            {\n              headers: {\n                'X-Idempotency-Key': '123456',\n              },\n              // XXX: I'm not sure what these are, as they are not documented axios options,\n              // nor are they mentioned in our source\n              // @ts-expect-error\n              simple: false,\n              resolveWithFullResponse: true,\n            }\n          );\n\n          sessionIds.push(sessionId);\n          times++;\n        } while (times < 2);\n        _.uniq(sessionIds).length.should.equal(1);\n\n        const {status, data} = await endSession(sessionIds[0]);\n        status.should.equal(200);\n        should.equal(data.value, null);\n      });\n\n      it('should handle idempotency while creating parallel sessions', async function () {\n        const reqs = [];\n        let times = 0;\n        do {\n          reqs.push(\n            startSession(\n              {\n                capabilities: {\n                  alwaysMatch: defaultCaps,\n                },\n              },\n              {\n                headers: {\n                  'X-Idempotency-Key': '12345',\n                },\n              }\n            )\n          );\n          times++;\n        } while (times < 2);\n        const sessionIds = _.map(await B.all(reqs), 'sessionId');\n        _.uniq(sessionIds).length.should.equal(1);\n\n        const {status, data} = await endSession(sessionIds[0]);\n        status.should.equal(200);\n        should.equal(data.value, null);\n      });\n\n      it('should create session and retrieve a session id, then delete it', async function () {\n        let {status, data} = await axios.post(newSessionURL, {\n          capabilities: {\n            alwaysMatch: defaultCaps,\n          },\n        });\n\n        status.should.equal(200);\n        should.exist(data.value.sessionId);\n        data.value.capabilities.platformName.should.equal(defaultCaps.platformName);\n        data.value.capabilities.deviceName.should.equal(defaultCaps['appium:deviceName']);\n\n        ({status, data} = await endSession(/** @type {string} */ (d.sessionId)));\n\n        status.should.equal(200);\n        should.equal(data.value, null);\n        should.equal(d.sessionId, null);\n      });\n    });\n\n    it.skip('should throw NYI for commands not implemented', async function () {});\n\n    describe('command timeouts', function () {\n      let originalFindElement, originalFindElements;\n\n      /**\n       * @param {number} [timeout]\n       */\n      async function startTimeoutSession(timeout) {\n        const caps = _.cloneDeep(defaultCaps);\n        caps['appium:newCommandTimeout'] = timeout;\n        return await startSession({capabilities: {alwaysMatch: caps}});\n      }\n\n      before(function () {\n        originalFindElement = d.findElement;\n        d.findElement = function () {\n          return 'foo';\n        }.bind(d);\n\n        originalFindElements = d.findElements;\n        d.findElements = async function () {\n          await B.delay(200);\n          return ['foo'];\n        }.bind(d);\n      });\n\n      after(function () {\n        d.findElement = originalFindElement;\n        d.findElements = originalFindElements;\n      });\n\n      it('should set a default commandTimeout', async function () {\n        let newSession = await startTimeoutSession();\n        d.newCommandTimeoutMs.should.be.above(0);\n        await endSession(newSession.sessionId);\n      });\n\n      it('should timeout on commands using commandTimeout cap', async function () {\n        let newSession = await startTimeoutSession(0.25);\n        const sessionId = /** @type {string} */ (d.sessionId);\n        await postCommand(sessionId, 'element', {\n          using: 'name',\n          value: 'foo',\n        });\n        await B.delay(400);\n        const value = await getSession(sessionId);\n        should.equal(value.error, 'invalid session id');\n        should.equal(d.sessionId, null);\n        const resp = (await endSession(newSession.sessionId)).data.value;\n        should.equal(resp?.error, 'invalid session id');\n      });\n\n      it('should not timeout with commandTimeout of false', async function () {\n        let newSession = await startTimeoutSession(0.1);\n        let start = Date.now();\n        const value = await postCommand(/** @type {string} */ (d.sessionId), 'elements', {\n          using: 'name',\n          value: 'foo',\n        });\n        (Date.now() - start).should.be.above(150);\n        value.should.eql(['foo']);\n        await endSession(newSession.sessionId);\n      });\n\n      it('should not timeout with commandTimeout of 0', async function () {\n        d.newCommandTimeoutMs = 2;\n        let newSession = await startTimeoutSession(0);\n\n        await postCommand(/** @type {string} */ (d.sessionId), 'element', {\n          using: 'name',\n          value: 'foo',\n        });\n        await B.delay(400);\n        const value = await getSession(/** @type {string} */ (d.sessionId));\n        value.platformName?.should.equal(defaultCaps.platformName);\n        const resp = (await endSession(newSession.sessionId)).data.value;\n        should.equal(resp, null);\n\n        d.newCommandTimeoutMs = 60 * 1000;\n      });\n\n      it('should not timeout if its just the command taking awhile', async function () {\n        let newSession = await startTimeoutSession(0.25);\n        // XXX: race condition: we must build this URL before ...something happens...\n        // which causes `d.sessionId` to be missing\n        const {sessionId} = d;\n\n        await postCommand(/** @type {string} */ (d.sessionId), 'element', {\n          using: 'name',\n          value: 'foo',\n        });\n        await B.delay(400);\n        const value = await getSession(/** @type {string} */ (sessionId));\n        value.error.should.equal('invalid session id');\n        should.equal(d.sessionId, null);\n        const resp = (await endSession(newSession.sessionId)).data.value;\n        /** @type {string} */ (/** @type { {error: string} } */ (resp).error).should.equal(\n          'invalid session id'\n        );\n      });\n\n      it('should not have a timer running before or after a session', async function () {\n        // @ts-expect-error\n        should.not.exist(d.noCommandTimer);\n        let newSession = await startTimeoutSession(0.25);\n        newSession.sessionId.should.equal(d.sessionId);\n        // @ts-expect-error\n        should.exist(d.noCommandTimer);\n        await endSession(newSession.sessionId);\n        // @ts-expect-error\n        should.not.exist(d.noCommandTimer);\n      });\n    });\n\n    describe('settings api', function () {\n      before(function () {\n        d.settings = new DeviceSettings({ignoreUnimportantViews: false});\n      });\n      it('should be able to get settings object', function () {\n        d.settings.getSettings().ignoreUnimportantViews.should.be.false;\n      });\n      it('should not reject when `updateSettings` method is not provided', async function () {\n        await d.settings.update({ignoreUnimportantViews: true}).should.not.be.rejected;\n      });\n      it('should reject for invalid update object', async function () {\n        await d.settings\n          // @ts-expect-error\n          .update('invalid json')\n          .should.be.rejectedWith('JSON');\n      });\n    });\n\n    describe('unexpected exits', function () {\n      /** @type {import('sinon').SinonSandbox} */\n      let sandbox;\n      beforeEach(function () {\n        sandbox = sinon.createSandbox();\n      });\n\n      afterEach(function () {\n        sandbox.restore();\n      });\n\n      it('should reject a current command when the driver crashes', async function () {\n        sandbox.stub(d, 'getStatus').callsFake(async function () {\n          await B.delay(5000);\n        });\n        const reqPromise = getCommand('status', {validateStatus: null});\n        // make sure that the request gets to the server before our shutdown\n        await B.delay(100);\n        const shutdownEventPromise = new B((resolve, reject) => {\n          setTimeout(\n            () =>\n              reject(\n                new Error(\n                  'onUnexpectedShutdown event is expected to be fired within 5 seconds timeout'\n                )\n              ),\n            5000\n          );\n          d.onUnexpectedShutdown(resolve);\n        });\n        d.startUnexpectedShutdown(new Error('Crashytimes'));\n        const value = await reqPromise;\n        value.message.should.contain('Crashytimes');\n        await shutdownEventPromise;\n      });\n    });\n\n    describe('event timings', function () {\n      it('should not add timings if not using opt-in cap', async function () {\n        const session = await startSession({capabilities: {alwaysMatch: defaultCaps}});\n        const res = await getSession(session.sessionId);\n        should.not.exist(res.events);\n        await endSession(session.sessionId);\n      });\n      it('should add start session timings', async function () {\n        const caps = {...defaultCaps, 'appium:eventTimings': true};\n        const session = await startSession({capabilities: {alwaysMatch: caps}});\n        const res = await getSession(session.sessionId);\n        should.exist(res.events);\n        should.exist(res.events?.newSessionRequested);\n        should.exist(res.events?.newSessionStarted);\n        res.events?.newSessionRequested[0].should.be.a('number');\n        res.events?.newSessionStarted[0].should.be.a('number');\n        await endSession(session.sessionId);\n      });\n    });\n  });\n}\n\n/**\n * A {@linkcode DriverClass}, except using the base {@linkcode Driver} type instead of `ExternalDriver`.\n * This allows the suite to work for `BaseDriver`.\n * @template {Driver} P\n * @typedef {import('@appium/types').DriverClass<P>} DriverClass\n */\n\n/**\n * @typedef {import('@appium/types').Capabilities} Capabilities\n * @typedef {import('@appium/types').Driver} Driver\n * @typedef {import('@appium/types').DriverStatic} DriverStatic\n * @typedef {import('@appium/types').AppiumW3CCapabilities} AppiumW3CCapabilities\n * @typedef {import('axios').AxiosRequestConfig} AxiosRequestConfig\n * @typedef {import('@appium/types').SingularSessionData} SingularSessionData\n */\n\n/**\n * @template T,D\n * @typedef {import('axios').AxiosResponse<T, D>} AxiosResponse\n */\n\n/**\n * @typedef NewSessionData\n * @property {import('type-fest').RequireAtLeastOne<import('@appium/types').W3CCapabilities, 'firstMatch'|'alwaysMatch'>} capabilities\n */\n\n/**\n * @typedef NewSessionResponse\n * @property {string} sessionId,\n * @property {import('@appium/types').Capabilities} capabilities\n */\n\n/**\n * Some E2E helpers for making requests and managing sessions\n * See {@linkcode createSessionHelpers}\n * @template [CommandData=unknown]\n * @template [ResponseData=any]\n * @typedef SessionHelpers\n * @property {string} newSessionURL - URL to create a new session. Can be used with raw `axios` requests to fully inspect raw response.  Mostly, this will not be used.\n * @property {(data: NewSessionData, config?: AxiosRequestConfig) => Promise<NewSessionResponse>} startSession - Begin a session\n * @property {(sessionId: string) => Promise<AxiosResponse<{value: {error?: string}?}, {validateStatus: null}>>} endSession - End a session. _Note: resolves with raw response object_\n * @property {(sessionId: string) => Promise<SingularSessionData>} getSession - Get info about a session\n * @property {(sessionId: string, cmdName: string, data?: CommandData, config?: AxiosRequestConfig) => Promise<ResponseData>} postCommand - Send an arbitrary command via `POST`.\n * @property {(sessionIdOrCmdName: string, cmdNameOrConfig: string|AxiosRequestConfig, config?: AxiosRequestConfig) => Promise<ResponseData>} getCommand - Send an arbitrary command via `GET`. Optional `sessionId`.\n */\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["should","chai","createSessionHelpers","port","address","TEST_HOST","createAppiumTestURL","createAppiumURL","createSessionURL","_","newSessionURL","postCommand","sessionId","cmdName","data","config","url","response","axios","post","value","getCommand","sessionIdOrCmdName","cmdNameOrConfig","isString","validateStatus","startSession","defaultsDeep","capabilities","alwaysMatch","firstMatch","endSession","delete","getSession","driverE2ETestSuite","DriverClass","defaultCaps","className","name","describe","baseServer","d","before","getTestPort","server","routeConfiguringFunction","hostname","cliArgs","after","close","it","sessionIds","times","headers","simple","resolveWithFullResponse","push","uniq","length","equal","status","reqs","map","B","all","exist","platformName","deviceName","skip","originalFindElement","originalFindElements","startTimeoutSession","timeout","caps","cloneDeep","findElement","bind","findElements","delay","newSession","newCommandTimeoutMs","be","above","using","error","resp","start","Date","now","eql","not","noCommandTimer","settings","DeviceSettings","ignoreUnimportantViews","getSettings","false","update","rejected","rejectedWith","sandbox","beforeEach","sinon","createSandbox","afterEach","restore","stub","callsFake","reqPromise","shutdownEventPromise","resolve","reject","setTimeout","Error","onUnexpectedShutdown","startUnexpectedShutdown","message","contain","session","res","events","newSessionRequested","newSessionStarted","a"],"sources":["../../lib/e2e-suite.js"],"sourcesContent":["import _ from 'lodash';\nimport {server, routeConfiguringFunction, DeviceSettings} from 'appium/driver';\nimport axios from 'axios';\nimport B from 'bluebird';\nimport {TEST_HOST, getTestPort, createAppiumURL} from './helpers';\nimport chai from 'chai';\nimport sinon from 'sinon';\n\nconst should = chai.should();\n\n/**\n * Creates some helper functions for E2E tests to manage sessions.\n * @template [CommandData=unknown]\n * @template [ResponseData=any]\n * @param {number} port - Port on which the server is running. Typically this will be retrieved via `get-port` beforehand\n * @param {string} [address] - Address/host on which the server is running. Defaults to {@linkcode TEST_HOST}\n * @returns {SessionHelpers<CommandData, ResponseData>}\n */\nexport function createSessionHelpers(port, address = TEST_HOST) {\n  const createAppiumTestURL =\n    /** @type {import('lodash').CurriedFunction2<string,string,string>} */ (\n      createAppiumURL(address, port)\n    );\n\n  const createSessionURL = createAppiumTestURL(_, '');\n  const newSessionURL = createAppiumTestURL('', 'session');\n  return /** @type {SessionHelpers<CommandData, ResponseData>} */ ({\n    newSessionURL,\n    createAppiumTestURL,\n    /**\n     *\n     * @param {string} sessionId\n     * @param {string} cmdName\n     * @param {any} [data]\n     * @param {AxiosRequestConfig} [config]\n     * @returns {Promise<any>}\n     */\n    postCommand: async (sessionId, cmdName, data = {}, config = {}) => {\n      const url = createAppiumTestURL(sessionId, cmdName);\n      const response = await axios.post(url, data, config);\n      return response.data?.value;\n    },\n    /**\n     *\n     * @param {string} sessionIdOrCmdName\n     * @param {string|AxiosRequestConfig} cmdNameOrConfig\n     * @param {AxiosRequestConfig} [config]\n     * @returns {Promise<any>}\n     */\n    getCommand: async (sessionIdOrCmdName, cmdNameOrConfig, config = {}) => {\n      if (!_.isString(cmdNameOrConfig)) {\n        config = cmdNameOrConfig;\n        cmdNameOrConfig = sessionIdOrCmdName;\n        sessionIdOrCmdName = '';\n      }\n      const response = await axios({\n        url: createAppiumTestURL(sessionIdOrCmdName, cmdNameOrConfig),\n        validateStatus: null,\n        ...config,\n      });\n      return response.data?.value;\n    },\n    /**\n     *\n     * @param {NewSessionData} data\n     * @param {AxiosRequestConfig} [config]\n     */\n    startSession: async (data, config = {}) => {\n      data = _.defaultsDeep(data, {\n        capabilities: {\n          alwaysMatch: {},\n          firstMatch: [{}],\n        },\n      });\n      const response = await axios.post(newSessionURL, data, config);\n      return response.data?.value;\n    },\n    /**\n     *\n     * @param {string} sessionId\n     */\n    endSession: async (sessionId) =>\n      await axios.delete(createSessionURL(sessionId), {\n        validateStatus: null,\n      }),\n    /**\n     * @param {string} sessionId\n     * @returns {Promise<any>}\n     */\n    getSession: async (sessionId) => {\n      const response = await axios({\n        url: createSessionURL(sessionId),\n        validateStatus: null,\n      });\n      return response.data?.value;\n    },\n  });\n}\n\n/**\n * Creates E2E test suites for a driver.\n * @template {Driver} P\n * @param {DriverClass<P>} DriverClass\n * @param {Partial<BaseNSCapabilities>} [defaultCaps]\n */\nexport function driverE2ETestSuite(DriverClass, defaultCaps = {}) {\n  let address = defaultCaps['appium:address'] ?? TEST_HOST;\n  let port = defaultCaps['appium:port'];\n  const className = DriverClass.name || '(unknown driver)';\n\n  describe(`BaseDriver E2E (as ${className})`, function () {\n    let baseServer;\n    /** @type {P} */\n    let d;\n    /**\n     * This URL creates a new session\n     * @type {string}\n     **/\n    let newSessionURL;\n\n    /** @type {SessionHelpers['startSession']} */\n    let startSession;\n    /** @type {SessionHelpers['getSession']} */\n    let getSession;\n    /** @type {SessionHelpers['endSession']} */\n    let endSession;\n    /** @type {SessionHelpers['getCommand']} */\n    let getCommand;\n    /** @type {SessionHelpers['postCommand']} */\n    let postCommand;\n    before(async function () {\n      port = port ?? (await getTestPort());\n      defaultCaps = {...defaultCaps};\n      d = new DriverClass({port, address});\n      baseServer = await server({\n        routeConfiguringFunction: routeConfiguringFunction(d),\n        port,\n        hostname: address,\n        // @ts-expect-error\n        cliArgs: {},\n      });\n      ({startSession, getSession, endSession, newSessionURL, getCommand, postCommand} =\n        createSessionHelpers(port, address));\n    });\n\n    after(async function () {\n      await baseServer.close();\n    });\n\n    describe('session handling', function () {\n      it('should handle idempotency while creating sessions', async function () {\n        const sessionIds = [];\n        let times = 0;\n        do {\n          const {sessionId} = await startSession(\n            {\n              capabilities: {alwaysMatch: defaultCaps},\n            },\n            {\n              headers: {\n                'X-Idempotency-Key': '123456',\n              },\n              // XXX: I'm not sure what these are, as they are not documented axios options,\n              // nor are they mentioned in our source\n              // @ts-expect-error\n              simple: false,\n              resolveWithFullResponse: true,\n            }\n          );\n\n          sessionIds.push(sessionId);\n          times++;\n        } while (times < 2);\n        _.uniq(sessionIds).length.should.equal(1);\n\n        const {status, data} = await endSession(sessionIds[0]);\n        status.should.equal(200);\n        should.equal(data.value, null);\n      });\n\n      it('should handle idempotency while creating parallel sessions', async function () {\n        const reqs = [];\n        let times = 0;\n        do {\n          reqs.push(\n            startSession(\n              {\n                capabilities: {\n                  alwaysMatch: defaultCaps,\n                },\n              },\n              {\n                headers: {\n                  'X-Idempotency-Key': '12345',\n                },\n              }\n            )\n          );\n          times++;\n        } while (times < 2);\n        const sessionIds = _.map(await B.all(reqs), 'sessionId');\n        _.uniq(sessionIds).length.should.equal(1);\n\n        const {status, data} = await endSession(sessionIds[0]);\n        status.should.equal(200);\n        should.equal(data.value, null);\n      });\n\n      it('should create session and retrieve a session id, then delete it', async function () {\n        let {status, data} = await axios.post(newSessionURL, {\n          capabilities: {\n            alwaysMatch: defaultCaps,\n          },\n        });\n\n        status.should.equal(200);\n        should.exist(data.value.sessionId);\n        data.value.capabilities.platformName.should.equal(defaultCaps.platformName);\n        data.value.capabilities.deviceName.should.equal(defaultCaps['appium:deviceName']);\n\n        ({status, data} = await endSession(/** @type {string} */ (d.sessionId)));\n\n        status.should.equal(200);\n        should.equal(data.value, null);\n        should.equal(d.sessionId, null);\n      });\n    });\n\n    it.skip('should throw NYI for commands not implemented', async function () {});\n\n    describe('command timeouts', function () {\n      let originalFindElement, originalFindElements;\n\n      /**\n       * @param {number} [timeout]\n       */\n      async function startTimeoutSession(timeout) {\n        const caps = _.cloneDeep(defaultCaps);\n        caps['appium:newCommandTimeout'] = timeout;\n        return await startSession({capabilities: {alwaysMatch: caps}});\n      }\n\n      before(function () {\n        originalFindElement = d.findElement;\n        d.findElement = function () {\n          return 'foo';\n        }.bind(d);\n\n        originalFindElements = d.findElements;\n        d.findElements = async function () {\n          await B.delay(200);\n          return ['foo'];\n        }.bind(d);\n      });\n\n      after(function () {\n        d.findElement = originalFindElement;\n        d.findElements = originalFindElements;\n      });\n\n      it('should set a default commandTimeout', async function () {\n        let newSession = await startTimeoutSession();\n        d.newCommandTimeoutMs.should.be.above(0);\n        await endSession(newSession.sessionId);\n      });\n\n      it('should timeout on commands using commandTimeout cap', async function () {\n        let newSession = await startTimeoutSession(0.25);\n        const sessionId = /** @type {string} */ (d.sessionId);\n        await postCommand(sessionId, 'element', {\n          using: 'name',\n          value: 'foo',\n        });\n        await B.delay(400);\n        const value = await getSession(sessionId);\n        should.equal(value.error, 'invalid session id');\n        should.equal(d.sessionId, null);\n        const resp = (await endSession(newSession.sessionId)).data.value;\n        should.equal(resp?.error, 'invalid session id');\n      });\n\n      it('should not timeout with commandTimeout of false', async function () {\n        let newSession = await startTimeoutSession(0.1);\n        let start = Date.now();\n        const value = await postCommand(/** @type {string} */ (d.sessionId), 'elements', {\n          using: 'name',\n          value: 'foo',\n        });\n        (Date.now() - start).should.be.above(150);\n        value.should.eql(['foo']);\n        await endSession(newSession.sessionId);\n      });\n\n      it('should not timeout with commandTimeout of 0', async function () {\n        d.newCommandTimeoutMs = 2;\n        let newSession = await startTimeoutSession(0);\n\n        await postCommand(/** @type {string} */ (d.sessionId), 'element', {\n          using: 'name',\n          value: 'foo',\n        });\n        await B.delay(400);\n        const value = await getSession(/** @type {string} */ (d.sessionId));\n        value.platformName?.should.equal(defaultCaps.platformName);\n        const resp = (await endSession(newSession.sessionId)).data.value;\n        should.equal(resp, null);\n\n        d.newCommandTimeoutMs = 60 * 1000;\n      });\n\n      it('should not timeout if its just the command taking awhile', async function () {\n        let newSession = await startTimeoutSession(0.25);\n        // XXX: race condition: we must build this URL before ...something happens...\n        // which causes `d.sessionId` to be missing\n        const {sessionId} = d;\n\n        await postCommand(/** @type {string} */ (d.sessionId), 'element', {\n          using: 'name',\n          value: 'foo',\n        });\n        await B.delay(400);\n        const value = await getSession(/** @type {string} */ (sessionId));\n        /** @type {string} */ (value.error).should.equal('invalid session id');\n        should.equal(d.sessionId, null);\n        const resp = (await endSession(newSession.sessionId)).data.value;\n        /** @type {string} */ (/** @type { {error: string} } */ (resp).error).should.equal(\n          'invalid session id'\n        );\n      });\n\n      it('should not have a timer running before or after a session', async function () {\n        // @ts-expect-error\n        should.not.exist(d.noCommandTimer);\n        let newSession = await startTimeoutSession(0.25);\n        newSession.sessionId.should.equal(d.sessionId);\n        // @ts-expect-error\n        should.exist(d.noCommandTimer);\n        await endSession(newSession.sessionId);\n        // @ts-expect-error\n        should.not.exist(d.noCommandTimer);\n      });\n    });\n\n    describe('settings api', function () {\n      before(function () {\n        d.settings = new DeviceSettings({ignoreUnimportantViews: false});\n      });\n      it('should be able to get settings object', function () {\n        d.settings.getSettings().ignoreUnimportantViews.should.be.false;\n      });\n      it('should not reject when `updateSettings` method is not provided', async function () {\n        await d.settings.update({ignoreUnimportantViews: true}).should.not.be.rejected;\n      });\n      it('should reject for invalid update object', async function () {\n        await d.settings\n          // @ts-expect-error\n          .update('invalid json')\n          .should.be.rejectedWith('JSON');\n      });\n    });\n\n    describe('unexpected exits', function () {\n      /** @type {import('sinon').SinonSandbox} */\n      let sandbox;\n      beforeEach(function () {\n        sandbox = sinon.createSandbox();\n      });\n\n      afterEach(function () {\n        sandbox.restore();\n      });\n\n      it('should reject a current command when the driver crashes', async function () {\n        sandbox.stub(d, 'getStatus').callsFake(async function () {\n          await B.delay(5000);\n        });\n        const reqPromise = getCommand('status', {validateStatus: null});\n        // make sure that the request gets to the server before our shutdown\n        await B.delay(100);\n        const shutdownEventPromise = new B((resolve, reject) => {\n          setTimeout(\n            () =>\n              reject(\n                new Error(\n                  'onUnexpectedShutdown event is expected to be fired within 5 seconds timeout'\n                )\n              ),\n            5000\n          );\n          d.onUnexpectedShutdown(resolve);\n        });\n        d.startUnexpectedShutdown(new Error('Crashytimes'));\n        const value = await reqPromise;\n        value.message.should.contain('Crashytimes');\n        await shutdownEventPromise;\n      });\n    });\n\n    describe('event timings', function () {\n      it('should not add timings if not using opt-in cap', async function () {\n        const session = await startSession({capabilities: {alwaysMatch: defaultCaps}});\n        const res = await getSession(session.sessionId);\n        should.not.exist(res.events);\n        await endSession(session.sessionId);\n      });\n      it('should add start session timings', async function () {\n        const caps = {...defaultCaps, 'appium:eventTimings': true};\n        const session = await startSession({capabilities: {alwaysMatch: caps}});\n        const res = await getSession(session.sessionId);\n        should.exist(res.events);\n        should.exist(res.events?.newSessionRequested);\n        should.exist(res.events?.newSessionStarted);\n        res.events?.newSessionRequested[0].should.be.a('number');\n        res.events?.newSessionStarted[0].should.be.a('number');\n        await endSession(session.sessionId);\n      });\n    });\n  });\n}\n\n/**\n * A {@linkcode DriverClass}, except using the base {@linkcode Driver} type instead of `ExternalDriver`.\n * This allows the suite to work for `BaseDriver`.\n * @template {Driver} P\n * @typedef {import('@appium/types').DriverClass<P>} DriverClass\n */\n\n/**\n * @typedef {import('@appium/types').Driver} Driver\n * @typedef {import('@appium/types').Constraints} Constraints\n * @typedef {import('@appium/types').DriverStatic} DriverStatic\n * @typedef {import('@appium/types').StringRecord} StringRecord\n * @typedef {import('@appium/types').BaseDriverCapConstraints} BaseDriverCapConstraints\n * @typedef {import('@appium/types').BaseNSCapabilities} BaseNSCapabilities\n * @typedef {import('axios').AxiosRequestConfig} AxiosRequestConfig\n * @typedef {import('@appium/types').SingularSessionData} SingularSessionData\n */\n\n/**\n * @template T,D\n * @typedef {import('axios').AxiosResponse<T, D>} AxiosResponse\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template {StringRecord|void} [Extra=void]\n * @typedef NewSessionData\n * @property {import('type-fest').RequireAtLeastOne<import('@appium/types').W3CCapabilities<C, Extra>, 'firstMatch'|'alwaysMatch'>} capabilities\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template {StringRecord|void} [Extra=void]\n * @typedef NewSessionResponse\n * @property {string} sessionId,\n * @property {import('@appium/types').Capabilities<C, Extra>} capabilities\n */\n\n/**\n * Some E2E helpers for making requests and managing sessions\n * See {@linkcode createSessionHelpers}\n * @template [CommandData=unknown]\n * @template [ResponseData=any]\n * @typedef SessionHelpers\n * @property {string} newSessionURL - URL to create a new session. Can be used with raw `axios` requests to fully inspect raw response.  Mostly, this will not be used.\n * @property {(data: NewSessionData, config?: AxiosRequestConfig) => Promise<NewSessionResponse>} startSession - Begin a session\n * @property {(sessionId: string) => Promise<AxiosResponse<{value: {error?: string}?}, {validateStatus: null}>>} endSession - End a session. _Note: resolves with raw response object_\n * @property {(sessionId: string) => Promise<SingularSessionData>} getSession - Get info about a session\n * @property {(sessionId: string, cmdName: string, data?: CommandData, config?: AxiosRequestConfig) => Promise<ResponseData>} postCommand - Send an arbitrary command via `POST`.\n * @property {(sessionIdOrCmdName: string, cmdNameOrConfig: string|AxiosRequestConfig, config?: AxiosRequestConfig) => Promise<ResponseData>} getCommand - Send an arbitrary command via `GET`. Optional `sessionId`.\n */\n"],"mappings":"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"}

package/build/lib/e2e-suite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"e2e-suite.js","names":["should","chai","createSessionHelpers","port","address","TEST_HOST","createAppiumTestURL","createAppiumURL","createSessionURL","_","newSessionURL","postCommand","sessionId","cmdName","data","config","url","response","axios","post","value","getCommand","sessionIdOrCmdName","cmdNameOrConfig","isString","validateStatus","startSession","defaultsDeep","capabilities","alwaysMatch","firstMatch","endSession","delete","getSession","driverE2ETestSuite","DriverClass","defaultCaps","className","name","describe","baseServer","d","before","getTestPort","server","routeConfiguringFunction","hostname","cliArgs","after","close","it","sessionIds","times","headers","simple","resolveWithFullResponse","push","uniq","length","equal","status","reqs","map","B","all","exist","platformName","deviceName","skip","originalFindElement","originalFindElements","startTimeoutSession","timeout","caps","cloneDeep","findElement","bind","findElements","delay","newSession","newCommandTimeoutMs","be","above","using","error","resp","start","Date","now","eql","not","noCommandTimer","settings","DeviceSettings","ignoreUnimportantViews","getSettings","false","update","rejected","rejectedWith","sandbox","beforeEach","sinon","createSandbox","afterEach","restore","stub","callsFake","reqPromise","shutdownEventPromise","resolve","reject","setTimeout","Error","onUnexpectedShutdown","startUnexpectedShutdown","message","contain","session","res","events","newSessionRequested","newSessionStarted","a"],"sources":["../../lib/e2e-suite.js"],"sourcesContent":["import _ from 'lodash';\nimport {server, routeConfiguringFunction, DeviceSettings} from 'appium/driver';\nimport axios from 'axios';\nimport B from 'bluebird';\nimport {TEST_HOST, getTestPort, createAppiumURL} from './helpers';\nimport chai from 'chai';\nimport sinon from 'sinon';\n\nconst should = chai.should();\n\n/**\n * Creates some helper functions for E2E tests to manage sessions.\n * @template [CommandData=unknown]\n * @template [ResponseData=any]\n * @param {number} port - Port on which the server is running. Typically this will be retrieved via `get-port` beforehand\n * @param {string} [address] - Address/host on which the server is running. Defaults to {@linkcode TEST_HOST}\n * @returns {SessionHelpers<CommandData, ResponseData>}\n */\nexport function createSessionHelpers(port, address = TEST_HOST) {\n  const createAppiumTestURL =\n    /** @type {import('lodash').CurriedFunction2<string,string,string>} */ (\n      createAppiumURL(address, port)\n    );\n\n  const createSessionURL = createAppiumTestURL(_, '');\n  const newSessionURL = createAppiumTestURL('', 'session');\n  return /** @type {SessionHelpers<CommandData, ResponseData>} */ ({\n    newSessionURL,\n    createAppiumTestURL,\n    /**\n     *\n     * @param {string} sessionId\n     * @param {string} cmdName\n     * @param {any} [data]\n     * @param {AxiosRequestConfig} [config]\n     * @returns {Promise<any>}\n     */\n    postCommand: async (sessionId, cmdName, data = {}, config = {}) => {\n      const url = createAppiumTestURL(sessionId, cmdName);\n      const response = await axios.post(url, data, config);\n      return response.data?.value;\n    },\n    /**\n     *\n     * @param {string} sessionIdOrCmdName\n     * @param {string|AxiosRequestConfig} cmdNameOrConfig\n     * @param {AxiosRequestConfig} [config]\n     * @returns {Promise<any>}\n     */\n    getCommand: async (sessionIdOrCmdName, cmdNameOrConfig, config = {}) => {\n      if (!_.isString(cmdNameOrConfig)) {\n        config = cmdNameOrConfig;\n        cmdNameOrConfig = sessionIdOrCmdName;\n        sessionIdOrCmdName = '';\n      }\n      const response = await axios({\n        url: createAppiumTestURL(sessionIdOrCmdName, cmdNameOrConfig),\n        validateStatus: null,\n        ...config,\n      });\n      return response.data?.value;\n    },\n    /**\n     *\n     * @param {NewSessionData} data\n     * @param {AxiosRequestConfig} [config]\n     */\n    startSession: async (data, config = {}) => {\n      data = _.defaultsDeep(data, {\n        capabilities: {\n          alwaysMatch: {},\n          firstMatch: [{}],\n        },\n      });\n      const response = await axios.post(newSessionURL, data, config);\n      return response.data?.value;\n    },\n    /**\n     *\n     * @param {string} sessionId\n     */\n    endSession: async (sessionId) =>\n      await axios.delete(createSessionURL(sessionId), {\n        validateStatus: null,\n      }),\n    /**\n     * @param {string} sessionId\n     * @returns {Promise<any>}\n     */\n    getSession: async (sessionId) => {\n      const response = await axios({\n        url: createSessionURL(sessionId),\n        validateStatus: null,\n      });\n      return response.data?.value;\n    },\n  });\n}\n\n/**\n * Creates E2E test suites for a driver.\n * @template {Driver} P\n * @param {DriverClass<P>} DriverClass\n * @param {Partial<BaseNSCapabilities>} [defaultCaps]\n */\nexport function driverE2ETestSuite(DriverClass, defaultCaps = {}) {\n  let address = defaultCaps['appium:address'] ?? TEST_HOST;\n  let port = defaultCaps['appium:port'];\n  const className = DriverClass.name || '(unknown driver)';\n\n  describe(`BaseDriver E2E (as ${className})`, function () {\n    let baseServer;\n    /** @type {P} */\n    let d;\n    /**\n     * This URL creates a new session\n     * @type {string}\n     **/\n    let newSessionURL;\n\n    /** @type {SessionHelpers['startSession']} */\n    let startSession;\n    /** @type {SessionHelpers['getSession']} */\n    let getSession;\n    /** @type {SessionHelpers['endSession']} */\n    let endSession;\n    /** @type {SessionHelpers['getCommand']} */\n    let getCommand;\n    /** @type {SessionHelpers['postCommand']} */\n    let postCommand;\n    before(async function () {\n      port = port ?? (await getTestPort());\n      defaultCaps = {...defaultCaps};\n      d = new DriverClass({port, address});\n      baseServer = await server({\n        routeConfiguringFunction: routeConfiguringFunction(d),\n        port,\n        hostname: address,\n        // @ts-expect-error\n        cliArgs: {},\n      });\n      ({startSession, getSession, endSession, newSessionURL, getCommand, postCommand} =\n        createSessionHelpers(port, address));\n    });\n\n    after(async function () {\n      await baseServer.close();\n    });\n\n    describe('session handling', function () {\n      it('should handle idempotency while creating sessions', async function () {\n        const sessionIds = [];\n        let times = 0;\n        do {\n          const {sessionId} = await startSession(\n            {\n              capabilities: {alwaysMatch: defaultCaps},\n            },\n            {\n              headers: {\n                'X-Idempotency-Key': '123456',\n              },\n              // XXX: I'm not sure what these are, as they are not documented axios options,\n              // nor are they mentioned in our source\n              // @ts-expect-error\n              simple: false,\n              resolveWithFullResponse: true,\n            }\n          );\n\n          sessionIds.push(sessionId);\n          times++;\n        } while (times < 2);\n        _.uniq(sessionIds).length.should.equal(1);\n\n        const {status, data} = await endSession(sessionIds[0]);\n        status.should.equal(200);\n        should.equal(data.value, null);\n      });\n\n      it('should handle idempotency while creating parallel sessions', async function () {\n        const reqs = [];\n        let times = 0;\n        do {\n          reqs.push(\n            startSession(\n              {\n                capabilities: {\n                  alwaysMatch: defaultCaps,\n                },\n              },\n              {\n                headers: {\n                  'X-Idempotency-Key': '12345',\n                },\n              }\n            )\n          );\n          times++;\n        } while (times < 2);\n        const sessionIds = _.map(await B.all(reqs), 'sessionId');\n        _.uniq(sessionIds).length.should.equal(1);\n\n        const {status, data} = await endSession(sessionIds[0]);\n        status.should.equal(200);\n        should.equal(data.value, null);\n      });\n\n      it('should create session and retrieve a session id, then delete it', async function () {\n        let {status, data} = await axios.post(newSessionURL, {\n          capabilities: {\n            alwaysMatch: defaultCaps,\n          },\n        });\n\n        status.should.equal(200);\n        should.exist(data.value.sessionId);\n        data.value.capabilities.platformName.should.equal(defaultCaps.platformName);\n        data.value.capabilities.deviceName.should.equal(defaultCaps['appium:deviceName']);\n\n        ({status, data} = await endSession(/** @type {string} */ (d.sessionId)));\n\n        status.should.equal(200);\n        should.equal(data.value, null);\n        should.equal(d.sessionId, null);\n      });\n    });\n\n    it.skip('should throw NYI for commands not implemented', async function () {});\n\n    describe('command timeouts', function () {\n      let originalFindElement, originalFindElements;\n\n      /**\n       * @param {number} [timeout]\n       */\n      async function startTimeoutSession(timeout) {\n        const caps = _.cloneDeep(defaultCaps);\n        caps['appium:newCommandTimeout'] = timeout;\n        return await startSession({capabilities: {alwaysMatch: caps}});\n      }\n\n      before(function () {\n        originalFindElement = d.findElement;\n        d.findElement = function () {\n          return 'foo';\n        }.bind(d);\n\n        originalFindElements = d.findElements;\n        d.findElements = async function () {\n          await B.delay(200);\n          return ['foo'];\n        }.bind(d);\n      });\n\n      after(function () {\n        d.findElement = originalFindElement;\n        d.findElements = originalFindElements;\n      });\n\n      it('should set a default commandTimeout', async function () {\n        let newSession = await startTimeoutSession();\n        d.newCommandTimeoutMs.should.be.above(0);\n        await endSession(newSession.sessionId);\n      });\n\n      it('should timeout on commands using commandTimeout cap', async function () {\n        let newSession = await startTimeoutSession(0.25);\n        const sessionId = /** @type {string} */ (d.sessionId);\n        await postCommand(sessionId, 'element', {\n          using: 'name',\n          value: 'foo',\n        });\n        await B.delay(400);\n        const value = await getSession(sessionId);\n        should.equal(value.error, 'invalid session id');\n        should.equal(d.sessionId, null);\n        const resp = (await endSession(newSession.sessionId)).data.value;\n        should.equal(resp?.error, 'invalid session id');\n      });\n\n      it('should not timeout with commandTimeout of false', async function () {\n        let newSession = await startTimeoutSession(0.1);\n        let start = Date.now();\n        const value = await postCommand(/** @type {string} */ (d.sessionId), 'elements', {\n          using: 'name',\n          value: 'foo',\n        });\n        (Date.now() - start).should.be.above(150);\n        value.should.eql(['foo']);\n        await endSession(newSession.sessionId);\n      });\n\n      it('should not timeout with commandTimeout of 0', async function () {\n        d.newCommandTimeoutMs = 2;\n        let newSession = await startTimeoutSession(0);\n\n        await postCommand(/** @type {string} */ (d.sessionId), 'element', {\n          using: 'name',\n          value: 'foo',\n        });\n        await B.delay(400);\n        const value = await getSession(/** @type {string} */ (d.sessionId));\n        value.platformName?.should.equal(defaultCaps.platformName);\n        const resp = (await endSession(newSession.sessionId)).data.value;\n        should.equal(resp, null);\n\n        d.newCommandTimeoutMs = 60 * 1000;\n      });\n\n      it('should not timeout if its just the command taking awhile', async function () {\n        let newSession = await startTimeoutSession(0.25);\n        // XXX: race condition: we must build this URL before ...something happens...\n        // which causes `d.sessionId` to be missing\n        const {sessionId} = d;\n\n        await postCommand(/** @type {string} */ (d.sessionId), 'element', {\n          using: 'name',\n          value: 'foo',\n        });\n        await B.delay(400);\n        const value = await getSession(/** @type {string} */ (sessionId));\n        /** @type {string} */ (value.error).should.equal('invalid session id');\n        should.equal(d.sessionId, null);\n        const resp = (await endSession(newSession.sessionId)).data.value;\n        /** @type {string} */ (/** @type { {error: string} } */ (resp).error).should.equal(\n          'invalid session id'\n        );\n      });\n\n      it('should not have a timer running before or after a session', async function () {\n        // @ts-expect-error\n        should.not.exist(d.noCommandTimer);\n        let newSession = await startTimeoutSession(0.25);\n        newSession.sessionId.should.equal(d.sessionId);\n        // @ts-expect-error\n        should.exist(d.noCommandTimer);\n        await endSession(newSession.sessionId);\n        // @ts-expect-error\n        should.not.exist(d.noCommandTimer);\n      });\n    });\n\n    describe('settings api', function () {\n      before(function () {\n        d.settings = new DeviceSettings({ignoreUnimportantViews: false});\n      });\n      it('should be able to get settings object', function () {\n        d.settings.getSettings().ignoreUnimportantViews.should.be.false;\n      });\n      it('should not reject when `updateSettings` method is not provided', async function () {\n        await d.settings.update({ignoreUnimportantViews: true}).should.not.be.rejected;\n      });\n      it('should reject for invalid update object', async function () {\n        await d.settings\n          // @ts-expect-error\n          .update('invalid json')\n          .should.be.rejectedWith('JSON');\n      });\n    });\n\n    describe('unexpected exits', function () {\n      /** @type {import('sinon').SinonSandbox} */\n      let sandbox;\n      beforeEach(function () {\n        sandbox = sinon.createSandbox();\n      });\n\n      afterEach(function () {\n        sandbox.restore();\n      });\n\n      it('should reject a current command when the driver crashes', async function () {\n        sandbox.stub(d, 'getStatus').callsFake(async function () {\n          await B.delay(5000);\n        });\n        const reqPromise = getCommand('status', {validateStatus: null});\n        // make sure that the request gets to the server before our shutdown\n        await B.delay(100);\n        const shutdownEventPromise = new B((resolve, reject) => {\n          setTimeout(\n            () =>\n              reject(\n                new Error(\n                  'onUnexpectedShutdown event is expected to be fired within 5 seconds timeout'\n                )\n              ),\n            5000\n          );\n          d.onUnexpectedShutdown(resolve);\n        });\n        d.startUnexpectedShutdown(new Error('Crashytimes'));\n        const value = await reqPromise;\n        value.message.should.contain('Crashytimes');\n        await shutdownEventPromise;\n      });\n    });\n\n    describe('event timings', function () {\n      it('should not add timings if not using opt-in cap', async function () {\n        const session = await startSession({capabilities: {alwaysMatch: defaultCaps}});\n        const res = await getSession(session.sessionId);\n        should.not.exist(res.events);\n        await endSession(session.sessionId);\n      });\n      it('should add start session timings', async function () {\n        const caps = {...defaultCaps, 'appium:eventTimings': true};\n        const session = await startSession({capabilities: {alwaysMatch: caps}});\n        const res = await getSession(session.sessionId);\n        should.exist(res.events);\n        should.exist(res.events?.newSessionRequested);\n        should.exist(res.events?.newSessionStarted);\n        res.events?.newSessionRequested[0].should.be.a('number');\n        res.events?.newSessionStarted[0].should.be.a('number');\n        await endSession(session.sessionId);\n      });\n    });\n  });\n}\n\n/**\n * A {@linkcode DriverClass}, except using the base {@linkcode Driver} type instead of `ExternalDriver`.\n * This allows the suite to work for `BaseDriver`.\n * @template {Driver} P\n * @typedef {import('@appium/types').DriverClass<P>} DriverClass\n */\n\n/**\n * @typedef {import('@appium/types').Driver} Driver\n * @typedef {import('@appium/types').Constraints} Constraints\n * @typedef {import('@appium/types').DriverStatic} DriverStatic\n * @typedef {import('@appium/types').StringRecord} StringRecord\n * @typedef {import('@appium/types').BaseDriverCapConstraints} BaseDriverCapConstraints\n * @typedef {import('@appium/types').BaseNSCapabilities} BaseNSCapabilities\n * @typedef {import('axios').AxiosRequestConfig} AxiosRequestConfig\n * @typedef {import('@appium/types').SingularSessionData} SingularSessionData\n */\n\n/**\n * @template T,D\n * @typedef {import('axios').AxiosResponse<T, D>} AxiosResponse\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template {StringRecord|void} [Extra=void]\n * @typedef NewSessionData\n * @property {import('type-fest').RequireAtLeastOne<import('@appium/types').W3CCapabilities<C, Extra>, 'firstMatch'|'alwaysMatch'>} capabilities\n */\n\n/**\n * @template {Constraints} [C=BaseDriverCapConstraints]\n * @template {StringRecord|void} [Extra=void]\n * @typedef NewSessionResponse\n * @property {string} sessionId,\n * @property {import('@appium/types').Capabilities<C, Extra>} capabilities\n */\n\n/**\n * Some E2E helpers for making requests and managing sessions\n * See {@linkcode createSessionHelpers}\n * @template [CommandData=unknown]\n * @template [ResponseData=any]\n * @typedef SessionHelpers\n * @property {string} newSessionURL - URL to create a new session. Can be used with raw `axios` requests to fully inspect raw response.  Mostly, this will not be used.\n * @property {(data: NewSessionData, config?: AxiosRequestConfig) => Promise<NewSessionResponse>} startSession - Begin a session\n * @property {(sessionId: string) => Promise<AxiosResponse<{value: {error?: string}?}, {validateStatus: null}>>} endSession - End a session. _Note: resolves with raw response object_\n * @property {(sessionId: string) => Promise<SingularSessionData>} getSession - Get info about a session\n * @property {(sessionId: string, cmdName: string, data?: CommandData, config?: AxiosRequestConfig) => Promise<ResponseData>} postCommand - Send an arbitrary command via `POST`.\n * @property {(sessionIdOrCmdName: string, cmdNameOrConfig: string|AxiosRequestConfig, config?: AxiosRequestConfig) => Promise<ResponseData>} getCommand - Send an arbitrary command via `GET`. Optional `sessionId`.\n */\n"],"mappings":"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"}

package/build/lib/helpers.js

@@ -1,7 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -14,6 +12,8 @@ var _getPort = _interopRequireDefault(require("get-port"));
 
 var _lodash = require("lodash");
 
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 const TEST_HOST = '127.0.0.1';
 exports.TEST_HOST = TEST_HOST;
 let testPort;
@@ -46,4 +46,4 @@ const createAppiumURL = (0, _lodash.curry)((address, port, session, pathname) =>
   return new URL(path, `${address}:${port}`).href;
 });
 exports.createAppiumURL = createAppiumURL;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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