@appium/test-support 1.3.22 → 1.5.0

package/README.md

@@ -1,14 +1,14 @@
-appium-test-support
+@appium/test-support
 ===================
 
 A collection of test utility lib used across Appium packages.
 
-[![Build Status](https://travis-ci.org/appium/appium-test-support.svg?branch=master)](https://travis-ci.org/appium/appium-test-support)
+[![Build Status](https://travis-ci.org/appium/@appium/test-support.svg?branch=master)](https://travis-ci.org/appium/@appium/test-support)
 
 ## Install
 
 ```
-npm install appium-test-support --save-dev
+npm install @appium/test-support --save-dev
 ```
 
 ## Api
@@ -16,7 +16,7 @@ npm install appium-test-support --save-dev
 ### stubEnv
 
 ```js
-import { stubEnv } from 'appium-test-support';
+import { stubEnv } from '@appium/test-support';
 
 describe('myTest', () => {
   stubEnv();
@@ -30,7 +30,7 @@ describe('myTest', () => {
 ### stubLog
 
 ```js
-import { stubLog } from 'appium-test-support';
+import { stubLog } from '@appium/test-support';
 
 describe('myTest', () => {
   let sandbox;
@@ -62,7 +62,7 @@ describe('myTest', () => {
 Use when mixing up sinon apis (mocks, spies stubs).
 
 ```js
-import { withSandbox } from 'appium-test-support';
+import { withSandbox } from '@appium/test-support';
 
 let api = {
   abc: () => { return 'abc'; }
@@ -85,7 +85,7 @@ describe('MyTest', withSandbox({mocks: {api}}, (S) => {
 When using mainly stubs.
 
 ```js
-import { withMocks } from 'appium-test-support';
+import { withMocks } from '@appium/test-support';
 
 let api = {
   abc: () => { return 'abc'; }
@@ -103,7 +103,7 @@ describe('withMocks', withMocks({api}, (mocks) => {
 ### fakeTime
 
 ```js
-import { fakeTime } from 'appium-test-support';
+import { fakeTime } from '@appium/test-support';
 
 function doSomething() {
   return new B.Promise((resolve) => {

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

@@ -0,0 +1,77 @@
+/**
+ * Creates some helper functions for E2E tests to manage sessions.
+ * @template [CommandData=unknown]
+ * @template [ResponseData=any]
+ * @param {number} port - Port on which the server is running. Typically this will be retrieved via `get-port` beforehand
+ * @param {string} [address] - Address/host on which the server is running. Defaults to {@linkcode TEST_HOST}
+ * @returns {SessionHelpers<CommandData, ResponseData>}
+ */
+export function createSessionHelpers<CommandData = unknown, ResponseData = any>(port: number, address?: string | undefined): SessionHelpers<CommandData, ResponseData>;
+/**
+ * Creates E2E test suites for a driver.
+ * @template {Driver} P
+ * @param {DriverClass<P>} DriverClass
+ * @param {AppiumW3CCapabilities} [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;
+/**
+ * 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 Driver = import('@appium/types').Driver;
+export type DriverStatic = import('@appium/types').DriverStatic;
+export type AppiumW3CCapabilities = import('@appium/types').AppiumW3CCapabilities;
+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 NewSessionResponse = {
+    /**
+     * ,
+     */
+    sessionId: string;
+    capabilities: import('@appium/types').Capabilities;
+};
+/**
+ * Some E2E helpers for making requests and managing sessions
+ * See {@linkcode createSessionHelpers }
+ */
+export type SessionHelpers<CommandData = unknown, ResponseData = any> = {
+    /**
+     * - URL to create a new session. Can be used with raw `axios` requests to fully inspect raw response.  Mostly, this will not be used.
+     */
+    newSessionURL: string;
+    /**
+     * - Begin a session
+     */
+    startSession: (data: NewSessionData, config?: AxiosRequestConfig) => Promise<NewSessionResponse>;
+    /**
+     * - End a session. _Note: resolves with raw response object_
+     */
+    endSession: (sessionId: string) => Promise<AxiosResponse<{
+        value: {
+            error?: string;
+        } | null;
+    }, {
+        validateStatus: null;
+    }>>;
+    /**
+     * - Get info about a session
+     */
+    getSession: (sessionId: string) => Promise<SingularSessionData>;
+    /**
+     * - Send an arbitrary command via `POST`.
+     */
+    postCommand: (sessionId: string, cmdName: string, data?: CommandData, config?: AxiosRequestConfig) => Promise<ResponseData>;
+    /**
+     * - Send an arbitrary command via `GET`. Optional `sessionId`.
+     */
+    getCommand: (sessionIdOrCmdName: string, cmdNameOrConfig: string | AxiosRequestConfig, config?: AxiosRequestConfig) => Promise<ResponseData>;
+};
+//# sourceMappingURL=driver-e2e-suite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"driver-e2e-suite.d.ts","sourceRoot":"","sources":["../../lib/driver-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"}

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

@@ -0,0 +1,389 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSessionHelpers = createSessionHelpers;
+exports.driverE2ETestSuite = driverE2ETestSuite;
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _driver = require("appium/driver");
+
+var _axios = _interopRequireDefault(require("axios"));
+
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+var _helpers = require("./helpers");
+
+var _chai = _interopRequireDefault(require("chai"));
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+const should = _chai.default.should();
+
+function createSessionHelpers(port, address = _helpers.TEST_HOST) {
+  const createAppiumTestURL = (0, _helpers.createAppiumURL)(address, port);
+  const createSessionURL = createAppiumTestURL(_lodash.default, '');
+  const newSessionURL = createAppiumTestURL('', 'session');
+  return {
+    newSessionURL,
+    createAppiumTestURL,
+    postCommand: async (sessionId, cmdName, data = {}, config = {}) => {
+      var _response$data;
+
+      const url = createAppiumTestURL(sessionId, cmdName);
+      const response = await _axios.default.post(url, data, config);
+      return (_response$data = response.data) === null || _response$data === void 0 ? void 0 : _response$data.value;
+    },
+    getCommand: async (sessionIdOrCmdName, cmdNameOrConfig, config = {}) => {
+      var _response$data2;
+
+      if (!_lodash.default.isString(cmdNameOrConfig)) {
+        config = cmdNameOrConfig;
+        cmdNameOrConfig = sessionIdOrCmdName;
+        sessionIdOrCmdName = '';
+      }
+
+      const response = await (0, _axios.default)({
+        url: createAppiumTestURL(sessionIdOrCmdName, cmdNameOrConfig),
+        validateStatus: null,
+        ...config
+      });
+      return (_response$data2 = response.data) === null || _response$data2 === void 0 ? void 0 : _response$data2.value;
+    },
+    startSession: async (data, config = {}) => {
+      var _response$data3;
+
+      data = _lodash.default.defaultsDeep(data, {
+        capabilities: {
+          alwaysMatch: {},
+          firstMatch: [{}]
+        }
+      });
+      const response = await _axios.default.post(newSessionURL, data, config);
+      return (_response$data3 = response.data) === null || _response$data3 === void 0 ? void 0 : _response$data3.value;
+    },
+    endSession: async sessionId => await _axios.default.delete(createSessionURL(sessionId), {
+      validateStatus: null
+    }),
+    getSession: async sessionId => {
+      var _response$data4;
+
+      const response = await (0, _axios.default)({
+        url: createSessionURL(sessionId),
+        validateStatus: null
+      });
+      return (_response$data4 = response.data) === null || _response$data4 === void 0 ? void 0 : _response$data4.value;
+    }
+  };
+}
+
+function driverE2ETestSuite(DriverClass, defaultCaps = {}) {
+  let address = defaultCaps['appium:address'] ?? _helpers.TEST_HOST;
+  let port = defaultCaps['appium:port'];
+  const className = DriverClass.name || '(unknown driver)';
+  describe(`BaseDriver E2E (as ${className})`, function () {
+    let baseServer;
+    let d;
+    let newSessionURL;
+    let startSession;
+    let getSession;
+    let endSession;
+    let getCommand;
+    let postCommand;
+    before(async function () {
+      port = port ?? (await (0, _helpers.getTestPort)());
+      defaultCaps = { ...defaultCaps,
+        'appium:port': port
+      };
+      d = new DriverClass({
+        port,
+        address
+      });
+      baseServer = await (0, _driver.server)({
+        routeConfiguringFunction: (0, _driver.routeConfiguringFunction)(d),
+        port,
+        hostname: address,
+        cliArgs: {}
+      });
+      ({
+        startSession,
+        getSession,
+        endSession,
+        newSessionURL,
+        getCommand,
+        postCommand
+      } = createSessionHelpers(port, address));
+    });
+    after(async function () {
+      await baseServer.close();
+    });
+    describe('session handling', function () {
+      it('should handle idempotency while creating sessions', async function () {
+        const sessionIds = [];
+        let times = 0;
+
+        do {
+          const {
+            sessionId
+          } = await startSession({
+            capabilities: {
+              alwaysMatch: defaultCaps
+            }
+          }, {
+            headers: {
+              'X-Idempotency-Key': '123456'
+            },
+            simple: false,
+            resolveWithFullResponse: true
+          });
+          sessionIds.push(sessionId);
+          times++;
+        } while (times < 2);
+
+        _lodash.default.uniq(sessionIds).length.should.equal(1);
+
+        const {
+          status,
+          data
+        } = await endSession(sessionIds[0]);
+        status.should.equal(200);
+        should.equal(data.value, null);
+      });
+      it('should handle idempotency while creating parallel sessions', async function () {
+        const reqs = [];
+        let times = 0;
+
+        do {
+          reqs.push(startSession({
+            capabilities: {
+              alwaysMatch: defaultCaps
+            }
+          }, {
+            headers: {
+              'X-Idempotency-Key': '12345'
+            }
+          }));
+          times++;
+        } while (times < 2);
+
+        const sessionIds = _lodash.default.map(await _bluebird.default.all(reqs), 'sessionId');
+
+        _lodash.default.uniq(sessionIds).length.should.equal(1);
+
+        const {
+          status,
+          data
+        } = await endSession(sessionIds[0]);
+        status.should.equal(200);
+        should.equal(data.value, null);
+      });
+      it('should create session and retrieve a session id, then delete it', async function () {
+        let {
+          status,
+          data
+        } = await _axios.default.post(newSessionURL, {
+          capabilities: {
+            alwaysMatch: defaultCaps
+          }
+        });
+        status.should.equal(200);
+        should.exist(data.value.sessionId);
+        data.value.capabilities.platformName.should.equal(defaultCaps.platformName);
+        data.value.capabilities.deviceName.should.equal(defaultCaps['appium:deviceName']);
+        ({
+          status,
+          data
+        } = await endSession(d.sessionId));
+        status.should.equal(200);
+        should.equal(data.value, null);
+        should.equal(d.sessionId, null);
+      });
+    });
+    it.skip('should throw NYI for commands not implemented', async function () {});
+    describe('command timeouts', function () {
+      let originalFindElement, originalFindElements;
+
+      async function startTimeoutSession(timeout) {
+        const caps = _lodash.default.cloneDeep(defaultCaps);
+
+        caps['appium:newCommandTimeout'] = timeout;
+        return await startSession({
+          capabilities: {
+            alwaysMatch: caps
+          }
+        });
+      }
+
+      before(function () {
+        originalFindElement = d.findElement;
+
+        d.findElement = function () {
+          return 'foo';
+        }.bind(d);
+
+        originalFindElements = d.findElements;
+
+        d.findElements = async function () {
+          await _bluebird.default.delay(200);
+          return ['foo'];
+        }.bind(d);
+      });
+      after(function () {
+        d.findElement = originalFindElement;
+        d.findElements = originalFindElements;
+      });
+      it('should set a default commandTimeout', async function () {
+        let newSession = await startTimeoutSession();
+        d.newCommandTimeoutMs.should.be.above(0);
+        await endSession(newSession.sessionId);
+      });
+      it('should timeout on commands using commandTimeout cap', async function () {
+        let newSession = await startTimeoutSession(0.25);
+        const sessionId = d.sessionId;
+        await postCommand(sessionId, 'element', {
+          using: 'name',
+          value: 'foo'
+        });
+        await _bluebird.default.delay(400);
+        const value = await getSession(sessionId);
+        should.equal(value.error, 'invalid session id');
+        should.equal(d.sessionId, null);
+        const resp = (await endSession(newSession.sessionId)).data.value;
+        should.equal(resp === null || resp === void 0 ? void 0 : resp.error, 'invalid session id');
+      });
+      it('should not timeout with commandTimeout of false', async function () {
+        let newSession = await startTimeoutSession(0.1);
+        let start = Date.now();
+        const value = await postCommand(d.sessionId, 'elements', {
+          using: 'name',
+          value: 'foo'
+        });
+        (Date.now() - start).should.be.above(150);
+        value.should.eql(['foo']);
+        await endSession(newSession.sessionId);
+      });
+      it('should not timeout with commandTimeout of 0', async function () {
+        var _value$platformName;
+
+        d.newCommandTimeoutMs = 2;
+        let newSession = await startTimeoutSession(0);
+        await postCommand(d.sessionId, 'element', {
+          using: 'name',
+          value: 'foo'
+        });
+        await _bluebird.default.delay(400);
+        const value = await getSession(d.sessionId);
+        (_value$platformName = value.platformName) === null || _value$platformName === void 0 ? void 0 : _value$platformName.should.equal(defaultCaps.platformName);
+        const resp = (await endSession(newSession.sessionId)).data.value;
+        should.equal(resp, null);
+        d.newCommandTimeoutMs = 60 * 1000;
+      });
+      it('should not timeout if its just the command taking awhile', async function () {
+        let newSession = await startTimeoutSession(0.25);
+        const {
+          sessionId
+        } = d;
+        await postCommand(d.sessionId, 'element', {
+          using: 'name',
+          value: 'foo'
+        });
+        await _bluebird.default.delay(400);
+        const value = await getSession(sessionId);
+        value.error.should.equal('invalid session id');
+        should.equal(d.sessionId, null);
+        const resp = (await endSession(newSession.sessionId)).data.value;
+        resp.error.should.equal('invalid session id');
+      });
+      it('should not have a timer running before or after a session', async function () {
+        should.not.exist(d.noCommandTimer);
+        let newSession = await startTimeoutSession(0.25);
+        newSession.sessionId.should.equal(d.sessionId);
+        should.exist(d.noCommandTimer);
+        await endSession(newSession.sessionId);
+        should.not.exist(d.noCommandTimer);
+      });
+    });
+    describe('settings api', function () {
+      before(function () {
+        d.settings = new _driver.DeviceSettings({
+          ignoreUnimportantViews: false
+        });
+      });
+      it('should be able to get settings object', function () {
+        d.settings.getSettings().ignoreUnimportantViews.should.be.false;
+      });
+      it('should not reject when `updateSettings` method is not provided', async function () {
+        await d.settings.update({
+          ignoreUnimportantViews: true
+        }).should.not.be.rejected;
+      });
+      it('should reject for invalid update object', async function () {
+        await d.settings.update('invalid json').should.be.rejectedWith('JSON');
+      });
+    });
+    describe('unexpected exits', function () {
+      let sandbox;
+      beforeEach(function () {
+        sandbox = _sinon.default.createSandbox();
+      });
+      afterEach(function () {
+        sandbox.restore();
+      });
+      it('should reject a current command when the driver crashes', async function () {
+        sandbox.stub(d, 'getStatus').callsFake(async function () {
+          await _bluebird.default.delay(5000);
+        });
+        const reqPromise = getCommand('status', {
+          validateStatus: null
+        });
+        await _bluebird.default.delay(100);
+        const shutdownEventPromise = new _bluebird.default((resolve, reject) => {
+          setTimeout(() => reject(new Error('onUnexpectedShutdown event is expected to be fired within 5 seconds timeout')), 5000);
+          d.onUnexpectedShutdown(resolve);
+        });
+        d.startUnexpectedShutdown(new Error('Crashytimes'));
+        const value = await reqPromise;
+        value.message.should.contain('Crashytimes');
+        await shutdownEventPromise;
+      });
+    });
+    describe('event timings', function () {
+      it('should not add timings if not using opt-in cap', async function () {
+        const session = await startSession({
+          capabilities: {
+            alwaysMatch: defaultCaps
+          }
+        });
+        const res = await getSession(session.sessionId);
+        should.not.exist(res.events);
+        await endSession(session.sessionId);
+      });
+      it('should add start session timings', async function () {
+        var _res$events, _res$events2, _res$events3, _res$events4;
+
+        const caps = { ...defaultCaps,
+          'appium:eventTimings': true
+        };
+        const session = await startSession({
+          capabilities: {
+            alwaysMatch: caps
+          }
+        });
+        const res = await getSession(session.sessionId);
+        should.exist(res.events);
+        should.exist((_res$events = res.events) === null || _res$events === void 0 ? void 0 : _res$events.newSessionRequested);
+        should.exist((_res$events2 = res.events) === null || _res$events2 === void 0 ? void 0 : _res$events2.newSessionStarted);
+        (_res$events3 = res.events) === null || _res$events3 === void 0 ? void 0 : _res$events3.newSessionRequested[0].should.be.a('number');
+        (_res$events4 = res.events) === null || _res$events4 === void 0 ? void 0 : _res$events4.newSessionStarted[0].should.be.a('number');
+        await endSession(session.sessionId);
+      });
+    });
+  });
+}
+//# 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/driver-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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"}

package/build/lib/driver-unit-suite.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Creates unit test suites for a driver.
+ * @param {DriverClass} DriverClass
+ * @param {AppiumW3CCapabilities} [defaultCaps]
+ */
+export function driverUnitTestSuite(DriverClass: DriverClass, defaultCaps?: Partial<import("@wdio/types/build/Capabilities").Capabilities & import("@wdio/types/build/Capabilities").AppiumW3CCapabilities & {
+    [x: `${string}:${string}`]: any;
+}> | undefined): void;
+export type DriverClass = import('@appium/types').DriverClass;
+export type W3CCapabilities = import('@appium/types').W3CCapabilities;
+export type AppiumW3CCapabilities = import('@appium/types').AppiumW3CCapabilities;
+//# sourceMappingURL=driver-unit-suite.d.ts.map

package/build/lib/driver-unit-suite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver-unit-suite.d.ts","sourceRoot":"","sources":["../../lib/driver-unit-suite.js"],"names":[],"mappings":"AAaA;;;;GAIG;AAEH,iDAJW,WAAW;;sBA4mBrB;0BAGY,OAAO,eAAe,EAAE,WAAW;8BACnC,OAAO,eAAe,EAAE,eAAe;oCACvC,OAAO,eAAe,EAAE,qBAAqB"}