@appium/driver-test-support 0.2.0

package/build/lib/unit-suite.js

@@ -0,0 +1,551 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.driverUnitTestSuite = driverUnitTestSuite;
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+var _sinon = require("sinon");
+
+var _chai = _interopRequireDefault(require("chai"));
+
+const should = _chai.default.should();
+
+const {
+  expect
+} = _chai.default;
+
+function driverUnitTestSuite(DriverClass, defaultCaps = {}) {
+  const className = DriverClass.name ?? '(unknown driver)';
+  describe(`BaseDriver unit suite (as ${className})`, function () {
+    let d;
+    let w3cCaps;
+    let sandbox;
+    beforeEach(function () {
+      sandbox = (0, _sinon.createSandbox)();
+      d = new DriverClass();
+      w3cCaps = {
+        alwaysMatch: { ...defaultCaps,
+          platformName: 'Fake',
+          'appium:deviceName': 'Commodore 64'
+        },
+        firstMatch: [{}]
+      };
+    });
+    afterEach(async function () {
+      sandbox.restore();
+      await d.deleteSession();
+    });
+    describe('static property', function () {
+      describe('baseVersion', function () {
+        it('should exist', function () {
+          DriverClass.baseVersion.should.exist;
+        });
+      });
+    });
+    describe('Log prefix', function () {
+      it('should setup log prefix', async function () {
+        const d = new DriverClass();
+        const previousPrefix = d.log.prefix;
+        await d.createSession({
+          alwaysMatch: { ...defaultCaps,
+            platformName: 'Fake',
+            'appium:deviceName': 'Commodore 64'
+          },
+          firstMatch: [{}]
+        });
+
+        try {
+          expect(previousPrefix).not.to.eql(d.log.prefix);
+        } finally {
+          await d.deleteSession();
+          expect(previousPrefix).to.eql(d.log.prefix);
+        }
+      });
+    });
+    it('should return an empty status object', async function () {
+      let status = await d.getStatus();
+      status.should.eql({});
+    });
+    it('should return a sessionId from createSession', async function () {
+      let [sessId] = await d.createSession(w3cCaps);
+      should.exist(sessId);
+      sessId.should.be.a('string');
+      sessId.length.should.be.above(5);
+    });
+    it('should not be able to start two sessions without closing the first', async function () {
+      await d.createSession(_lodash.default.cloneDeep(w3cCaps));
+      await d.createSession(_lodash.default.cloneDeep(w3cCaps)).should.be.rejectedWith('session');
+    });
+    it('should be able to delete a session', async function () {
+      let sessionId1 = await d.createSession(_lodash.default.cloneDeep(w3cCaps));
+      await d.deleteSession();
+      should.equal(d.sessionId, null);
+      let sessionId2 = await d.createSession(_lodash.default.cloneDeep(w3cCaps));
+      sessionId1.should.not.eql(sessionId2);
+    });
+    it('should get the current session', async function () {
+      let [, caps] = await d.createSession(w3cCaps);
+      caps.should.equal(await d.getSession());
+    });
+    it('should return sessions if no session exists', async function () {
+      let sessions = await d.getSessions();
+      sessions.length.should.equal(0);
+    });
+    it('should return sessions', async function () {
+      const caps = _lodash.default.cloneDeep(w3cCaps);
+
+      await d.createSession(caps);
+      let sessions = await d.getSessions();
+      sessions.length.should.equal(1);
+      sessions[0].should.include({
+        id: d.sessionId
+      });
+      sessions[0].capabilities.should.include({
+        deviceName: 'Commodore 64',
+        platformName: 'Fake'
+      });
+    });
+    it('should fulfill an unexpected driver quit promise', async function () {
+      sandbox.stub(d, 'getStatus').callsFake(async () => {
+        await _bluebird.default.delay(1000);
+        return 'good status';
+      });
+      let cmdPromise = d.executeCommand('getStatus');
+      await _bluebird.default.delay(10);
+      const p = 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('We crashed'));
+      await cmdPromise.should.be.rejectedWith(/We crashed/);
+      await p;
+    });
+    it('should not allow commands in middle of unexpected shutdown', async function () {
+      sandbox.stub(d, 'deleteSession').callsFake(async function () {
+        await _bluebird.default.delay(100);
+        DriverClass.prototype.deleteSession.call(this);
+      });
+      await d.createSession(w3cCaps);
+      const p = 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('We crashed'));
+      await p;
+      await d.executeCommand('getSession').should.be.rejectedWith(/shut down/);
+    });
+    it('should allow new commands after done shutting down', async function () {
+      sandbox.stub(d, 'deleteSession').callsFake(async function () {
+        await _bluebird.default.delay(100);
+        DriverClass.prototype.deleteSession.call(this);
+      });
+      await d.createSession(_lodash.default.cloneDeep(w3cCaps));
+      const p = 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('We crashed'));
+      await p;
+      await d.executeCommand('getSession').should.be.rejectedWith(/shut down/);
+      await _bluebird.default.delay(500);
+      await d.executeCommand('createSession', null, null, _lodash.default.cloneDeep(w3cCaps));
+      await d.deleteSession();
+    });
+    it('should distinguish between W3C and JSONWP session', async function () {
+      await d.executeCommand('createSession', null, null, {
+        alwaysMatch: { ...defaultCaps,
+          platformName: 'Fake',
+          'appium:deviceName': 'Commodore 64'
+        },
+        firstMatch: [{}]
+      });
+      expect(d.protocol).to.equal('W3C');
+    });
+    describe('protocol detection', function () {
+      it('should use W3C if only W3C caps are provided', async function () {
+        await d.createSession({
+          alwaysMatch: _lodash.default.clone(defaultCaps),
+          firstMatch: [{}]
+        });
+        expect(d.protocol).to.equal('W3C');
+      });
+    });
+    it('should have a method to get driver for a session', async function () {
+      let [sessId] = await d.createSession(w3cCaps);
+      expect(d.driverForSession(sessId)).to.eql(d);
+    });
+    describe('command queue', function () {
+      let d;
+      let waitMs = 10;
+      beforeEach(function () {
+        d = new DriverClass();
+        sandbox.stub(d, 'getStatus').callsFake(async () => {
+          await _bluebird.default.delay(waitMs);
+          return Date.now();
+        });
+        sandbox.stub(d, 'getSessions').callsFake(async () => {
+          await _bluebird.default.delay(waitMs);
+          throw new Error('multipass');
+        });
+      });
+      afterEach(async function () {
+        await d.clearNewCommandTimeout();
+      });
+      it('should queue commands and.executeCommand/respond in the order received', async function () {
+        let numCmds = 10;
+        let cmds = [];
+
+        for (let i = 0; i < numCmds; i++) {
+          cmds.push(d.executeCommand('getStatus'));
+        }
+
+        let results = await _bluebird.default.all(cmds);
+
+        for (let i = 1; i < numCmds; i++) {
+          if (results[i] <= results[i - 1]) {
+            throw new Error('Got result out of order');
+          }
+        }
+      });
+      it('should handle errors correctly when queuing', async function () {
+        let numCmds = 10;
+        let cmds = [];
+
+        for (let i = 0; i < numCmds; i++) {
+          if (i === 5) {
+            cmds.push(d.executeCommand('getSessions'));
+          } else {
+            cmds.push(d.executeCommand('getStatus'));
+          }
+        }
+
+        let results = await Promise.allSettled(cmds);
+
+        for (let i = 1; i < 5; i++) {
+          if (results[i].value <= results[i - 1].value) {
+            throw new Error('Got result out of order');
+          }
+        }
+
+        results[5].reason.message.should.contain('multipass');
+
+        for (let i = 7; i < numCmds; i++) {
+          if (results[i].value <= results[i - 1].value) {
+            throw new Error('Got result out of order');
+          }
+        }
+      });
+      it('should not care if queue empties for a bit', async function () {
+        let numCmds = 10;
+        let cmds = [];
+
+        for (let i = 0; i < numCmds; i++) {
+          cmds.push(d.executeCommand('getStatus'));
+        }
+
+        let results = await _bluebird.default.all(cmds);
+        cmds = [];
+
+        for (let i = 0; i < numCmds; i++) {
+          cmds.push(d.executeCommand('getStatus'));
+        }
+
+        results = await _bluebird.default.all(cmds);
+
+        for (let i = 1; i < numCmds; i++) {
+          if (results[i] <= results[i - 1]) {
+            throw new Error('Got result out of order');
+          }
+        }
+      });
+    });
+    describe('timeouts', function () {
+      before(async function () {
+        await d.createSession(w3cCaps);
+      });
+      describe('command', function () {
+        it('should exist by default', function () {
+          d.newCommandTimeoutMs.should.equal(60000);
+        });
+        it('should be settable through `timeouts`', async function () {
+          await d.timeouts('command', 20);
+          d.newCommandTimeoutMs.should.equal(20);
+        });
+      });
+      describe('implicit', function () {
+        it('should not exist by default', function () {
+          d.implicitWaitMs.should.equal(0);
+        });
+        it('should be settable through `timeouts`', async function () {
+          await d.timeouts('implicit', 20);
+          d.implicitWaitMs.should.equal(20);
+        });
+      });
+    });
+    describe('timeouts (W3C)', function () {
+      beforeEach(async function () {
+        await d.createSession(w3cCaps);
+      });
+      afterEach(async function () {
+        await d.deleteSession();
+      });
+      it('should get timeouts that we set', async function () {
+        await d.timeouts(undefined, undefined, undefined, undefined, 1000);
+        await d.getTimeouts().should.eventually.have.property('implicit', 1000);
+        await d.timeouts('command', 2000);
+        await d.getTimeouts().should.eventually.deep.equal({
+          implicit: 1000,
+          command: 2000
+        });
+        await d.timeouts(undefined, undefined, undefined, undefined, 3000);
+        await d.getTimeouts().should.eventually.deep.equal({
+          implicit: 3000,
+          command: 2000
+        });
+      });
+    });
+    describe('reset compatibility', function () {
+      it('should not allow both fullReset and noReset to be true', async function () {
+        const newCaps = {
+          alwaysMatch: { ...defaultCaps,
+            platformName: 'Fake',
+            'appium:deviceName': 'Commodore 64',
+            'appium:fullReset': true,
+            'appium:noReset': true
+          },
+          firstMatch: [{}]
+        };
+        await d.createSession(newCaps).should.be.rejectedWith(/noReset.+fullReset/);
+      });
+    });
+    describe('proxying', function () {
+      let sessId;
+      beforeEach(async function () {
+        [sessId] = await d.createSession(w3cCaps);
+      });
+      describe('#proxyActive', function () {
+        it('should exist', function () {
+          d.proxyActive.should.be.an.instanceof(Function);
+        });
+        it('should return false', function () {
+          d.proxyActive(sessId).should.be.false;
+        });
+        it('should throw an error when sessionId is wrong', function () {
+          (() => {
+            d.proxyActive('aaa');
+          }).should.throw;
+        });
+      });
+      describe('#getProxyAvoidList', function () {
+        it('should exist', function () {
+          d.getProxyAvoidList.should.be.an.instanceof(Function);
+        });
+        it('should return an array', function () {
+          d.getProxyAvoidList(sessId).should.be.an.instanceof(Array);
+        });
+        it('should throw an error when sessionId is wrong', function () {
+          (() => {
+            d.getProxyAvoidList('aaa');
+          }).should.throw;
+        });
+      });
+      describe('#canProxy', function () {
+        it('should have a #canProxy method', function () {
+          d.canProxy.should.be.an.instanceof(Function);
+        });
+        it('should return a boolean from #canProxy', function () {
+          d.canProxy(sessId).should.be.a('boolean');
+        });
+        it('should throw an error when sessionId is wrong', function () {
+          (() => {
+            d.canProxy();
+          }).should.throw;
+        });
+      });
+      describe('#proxyRouteIsAvoided', function () {
+        it('should validate form of avoidance list', function () {
+          const avoidStub = sandbox.stub(d, 'getProxyAvoidList');
+          avoidStub.returns([['POST', /\/foo/], ['GET']]);
+          (() => {
+            d.proxyRouteIsAvoided();
+          }).should.throw;
+          avoidStub.returns([['POST', /\/foo/], ['GET', /^foo/, 'bar']]);
+          (() => {
+            d.proxyRouteIsAvoided();
+          }).should.throw;
+        });
+        it('should reject bad http methods', function () {
+          const avoidStub = sandbox.stub(d, 'getProxyAvoidList');
+          avoidStub.returns([['POST', /^foo/], ['BAZETE', /^bar/]]);
+          (() => {
+            d.proxyRouteIsAvoided();
+          }).should.throw;
+        });
+        it('should reject non-regex routes', function () {
+          const avoidStub = sandbox.stub(d, 'getProxyAvoidList');
+          avoidStub.returns([['POST', /^foo/], ['GET', '/bar']]);
+          (() => {
+            d.proxyRouteIsAvoided();
+          }).should.throw;
+        });
+        it('should return true for routes in the avoid list', function () {
+          const avoidStub = sandbox.stub(d, 'getProxyAvoidList');
+          avoidStub.returns([['POST', /^\/foo/]]);
+          d.proxyRouteIsAvoided('foo', 'POST', '/foo/bar').should.be.true;
+        });
+        it('should strip away any wd/hub prefix', function () {
+          const avoidStub = sandbox.stub(d, 'getProxyAvoidList');
+          avoidStub.returns([['POST', /^\/foo/]]);
+          d.proxyRouteIsAvoided('foo', 'POST', '/foo/bar').should.be.true;
+        });
+        it('should return false for routes not in the avoid list', function () {
+          const avoidStub = sandbox.stub(d, 'getProxyAvoidList');
+          avoidStub.returns([['POST', /^\/foo/]]);
+          d.proxyRouteIsAvoided('foo', 'GET', '/foo/bar').should.be.false;
+          d.proxyRouteIsAvoided('foo', 'POST', '/boo').should.be.false;
+        });
+      });
+    });
+    describe('event timing framework', function () {
+      let beforeStartTime;
+      beforeEach(async function () {
+        beforeStartTime = Date.now();
+        d.shouldValidateCaps = false;
+        await d.executeCommand('createSession', null, null, {
+          alwaysMatch: { ...defaultCaps
+          },
+          firstMatch: [{}]
+        });
+      });
+      describe('#eventHistory', function () {
+        it('should have an eventHistory property', function () {
+          should.exist(d.eventHistory);
+          should.exist(d.eventHistory.commands);
+        });
+        it('should have a session start timing after session start', function () {
+          let {
+            newSessionRequested,
+            newSessionStarted
+          } = d.eventHistory;
+          newSessionRequested.should.have.length(1);
+          newSessionStarted.should.have.length(1);
+          newSessionRequested[0].should.be.a('number');
+          newSessionStarted[0].should.be.a('number');
+          (newSessionRequested[0] >= beforeStartTime).should.be.true;
+          (newSessionStarted[0] >= newSessionRequested[0]).should.be.true;
+        });
+        it('should include a commands list', async function () {
+          await d.executeCommand('getStatus', []);
+          d.eventHistory.commands.length.should.equal(2);
+          d.eventHistory.commands[1].cmd.should.equal('getStatus');
+          d.eventHistory.commands[1].startTime.should.be.a('number');
+          d.eventHistory.commands[1].endTime.should.be.a('number');
+        });
+      });
+      describe('#logEvent', function () {
+        it('should allow logging arbitrary events', function () {
+          d.logEvent('foo');
+          d.eventHistory.foo[0].should.be.a('number');
+          (d.eventHistory.foo[0] >= beforeStartTime).should.be.true;
+        });
+        it('should not allow reserved or oddly formed event names', function () {
+          (() => {
+            d.logEvent('commands');
+          }).should.throw();
+          (() => {
+            d.logEvent(1);
+          }).should.throw();
+          (() => {
+            d.logEvent({});
+          }).should.throw();
+        });
+      });
+      it('should allow logging the same event multiple times', function () {
+        d.logEvent('bar');
+        d.logEvent('bar');
+        d.eventHistory.bar.should.have.length(2);
+        d.eventHistory.bar[1].should.be.a('number');
+        (d.eventHistory.bar[1] >= d.eventHistory.bar[0]).should.be.true;
+      });
+      describe('getSession decoration', function () {
+        it('should decorate getSession response if opt-in cap is provided', async function () {
+          var _res$events, _res$events2;
+
+          let res = await d.getSession();
+          should.not.exist(res.events);
+
+          _lodash.default.set(d, 'caps.eventTimings', true);
+
+          res = await d.getSession();
+          should.exist(res.events);
+          should.exist((_res$events = res.events) === null || _res$events === void 0 ? void 0 : _res$events.newSessionRequested);
+          expect((_res$events2 = res.events) === null || _res$events2 === void 0 ? void 0 : _res$events2.newSessionRequested[0]).to.be.a('number');
+        });
+      });
+    });
+    describe('.reset', function () {
+      it('should reset as W3C if the original session was W3C', async function () {
+        const caps = {
+          alwaysMatch: {
+            'appium:app': 'Fake',
+            'appium:deviceName': 'Fake',
+            'appium:automationName': 'Fake',
+            platformName: 'Fake',
+            ...defaultCaps
+          },
+          firstMatch: [{}]
+        };
+        await d.createSession(caps);
+        expect(d.protocol).to.equal('W3C');
+        await d.reset();
+        expect(d.protocol).to.equal('W3C');
+      });
+    });
+  });
+  describe('.isFeatureEnabled', function () {
+    let d;
+    beforeEach(function () {
+      d = new DriverClass();
+    });
+    it('should say a feature is enabled when it is explicitly allowed', function () {
+      d.allowInsecure = ['foo', 'bar'];
+      d.isFeatureEnabled('foo').should.be.true;
+      d.isFeatureEnabled('bar').should.be.true;
+      d.isFeatureEnabled('baz').should.be.false;
+    });
+    it('should say a feature is not enabled if it is not enabled', function () {
+      d.allowInsecure = [];
+      d.isFeatureEnabled('foo').should.be.false;
+    });
+    it('should prefer denyInsecure to allowInsecure', function () {
+      d.allowInsecure = ['foo', 'bar'];
+      d.denyInsecure = ['foo'];
+      d.isFeatureEnabled('foo').should.be.false;
+      d.isFeatureEnabled('bar').should.be.true;
+      d.isFeatureEnabled('baz').should.be.false;
+    });
+    it('should allow global setting for insecurity', function () {
+      d.relaxedSecurityEnabled = true;
+      d.isFeatureEnabled('foo').should.be.true;
+      d.isFeatureEnabled('bar').should.be.true;
+      d.isFeatureEnabled('baz').should.be.true;
+    });
+    it('global setting should be overrideable', function () {
+      d.relaxedSecurityEnabled = true;
+      d.denyInsecure = ['foo', 'bar'];
+      d.isFeatureEnabled('foo').should.be.false;
+      d.isFeatureEnabled('bar').should.be.false;
+      d.isFeatureEnabled('baz').should.be.true;
+    });
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["should","chai","expect","driverUnitTestSuite","DriverClass","defaultCaps","className","name","describe","d","w3cCaps","sandbox","beforeEach","createSandbox","alwaysMatch","platformName","firstMatch","afterEach","restore","deleteSession","it","baseVersion","exist","previousPrefix","log","prefix","createSession","not","to","eql","status","getStatus","sessId","be","a","length","above","_","cloneDeep","rejectedWith","sessionId1","equal","sessionId","sessionId2","caps","getSession","sessions","getSessions","include","id","capabilities","deviceName","stub","callsFake","B","delay","cmdPromise","executeCommand","p","resolve","reject","setTimeout","Error","onUnexpectedShutdown","startUnexpectedShutdown","prototype","call","protocol","clone","driverForSession","waitMs","Date","now","clearNewCommandTimeout","numCmds","cmds","i","push","results","all","Promise","allSettled","value","reason","message","contain","before","newCommandTimeoutMs","timeouts","implicitWaitMs","undefined","getTimeouts","eventually","have","property","deep","implicit","command","newCaps","proxyActive","an","instanceof","Function","false","throw","getProxyAvoidList","Array","canProxy","avoidStub","returns","proxyRouteIsAvoided","true","beforeStartTime","shouldValidateCaps","eventHistory","commands","newSessionRequested","newSessionStarted","cmd","startTime","endTime","logEvent","foo","bar","res","events","set","reset","allowInsecure","isFeatureEnabled","denyInsecure","relaxedSecurityEnabled"],"sources":["../../lib/unit-suite.js"],"sourcesContent":["import _ from 'lodash';\nimport B from 'bluebird';\nimport {createSandbox} from 'sinon';\n\nimport chai from 'chai';\n\nconst should = chai.should();\nconst {expect} = chai;\n\n// wrap these tests in a function so we can export the tests and re-use them\n// for actual driver implementations\n\n/**\n * Creates unit test suites for a driver.\n * @param {DriverClass} DriverClass\n * @param {AppiumW3CCapabilities} [defaultCaps]\n */\n\nexport function driverUnitTestSuite(DriverClass, defaultCaps = {}) {\n  // to display the driver under test in report\n  const className = DriverClass.name ?? '(unknown driver)';\n\n  describe(`BaseDriver unit suite (as ${className})`, function () {\n    /** @type {InstanceType<typeof DriverClass>} */\n    let d;\n    /** @type {W3CCapabilities} */\n    let w3cCaps;\n    /** @type {import('sinon').SinonSandbox} */\n    let sandbox;\n\n    beforeEach(function () {\n      sandbox = createSandbox();\n      d = new DriverClass();\n      w3cCaps = {\n        alwaysMatch: {\n          ...defaultCaps,\n          platformName: 'Fake',\n          'appium:deviceName': 'Commodore 64',\n        },\n        firstMatch: [{}],\n      };\n    });\n    afterEach(async function () {\n      sandbox.restore();\n      await d.deleteSession();\n    });\n\n    describe('static property', function () {\n      describe('baseVersion', function () {\n        it('should exist', function () {\n          DriverClass.baseVersion.should.exist;\n        });\n      });\n    });\n\n    describe('Log prefix', function () {\n      it('should setup log prefix', async function () {\n        const d = new DriverClass();\n        const previousPrefix = d.log.prefix;\n        await d.createSession({\n          alwaysMatch: {...defaultCaps, platformName: 'Fake', 'appium:deviceName': 'Commodore 64'},\n          firstMatch: [{}],\n        });\n        try {\n          expect(previousPrefix).not.to.eql(d.log.prefix);\n        } finally {\n          await d.deleteSession();\n          expect(previousPrefix).to.eql(d.log.prefix);\n        }\n      });\n    });\n\n    it('should return an empty status object', async function () {\n      let status = await d.getStatus();\n      status.should.eql({});\n    });\n\n    it('should return a sessionId from createSession', async function () {\n      let [sessId] = await d.createSession(w3cCaps);\n      should.exist(sessId);\n      sessId.should.be.a('string');\n      sessId.length.should.be.above(5);\n    });\n\n    it('should not be able to start two sessions without closing the first', async function () {\n      await d.createSession(_.cloneDeep(w3cCaps));\n      await d.createSession(_.cloneDeep(w3cCaps)).should.be.rejectedWith('session');\n    });\n\n    it('should be able to delete a session', async function () {\n      let sessionId1 = await d.createSession(_.cloneDeep(w3cCaps));\n      await d.deleteSession();\n      should.equal(d.sessionId, null);\n      let sessionId2 = await d.createSession(_.cloneDeep(w3cCaps));\n      sessionId1.should.not.eql(sessionId2);\n    });\n\n    it('should get the current session', async function () {\n      let [, caps] = await d.createSession(w3cCaps);\n      caps.should.equal(await d.getSession());\n    });\n\n    it('should return sessions if no session exists', async function () {\n      let sessions = await d.getSessions();\n      sessions.length.should.equal(0);\n    });\n\n    it('should return sessions', async function () {\n      const caps = _.cloneDeep(w3cCaps);\n      await d.createSession(caps);\n      let sessions = await d.getSessions();\n\n      sessions.length.should.equal(1);\n      sessions[0].should.include({\n        id: d.sessionId,\n      });\n      sessions[0].capabilities.should.include({\n        deviceName: 'Commodore 64',\n        platformName: 'Fake',\n      });\n    });\n\n    it('should fulfill an unexpected driver quit promise', async function () {\n      // make a command that will wait a bit so we can crash while it's running\n      sandbox.stub(d, 'getStatus').callsFake(async () => {\n        await B.delay(1000);\n        return 'good status';\n      });\n      let cmdPromise = d.executeCommand('getStatus');\n      await B.delay(10);\n      const p = 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('We crashed'));\n      await cmdPromise.should.be.rejectedWith(/We crashed/);\n      await p;\n    });\n\n    it('should not allow commands in middle of unexpected shutdown', async function () {\n      // make a command that will wait a bit so we can crash while it's running\n      sandbox.stub(d, 'deleteSession').callsFake(async function () {\n        await B.delay(100);\n        DriverClass.prototype.deleteSession.call(this);\n      });\n      await d.createSession(w3cCaps);\n      const p = 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('We crashed'));\n      await p;\n      await d.executeCommand('getSession').should.be.rejectedWith(/shut down/);\n    });\n\n    it('should allow new commands after done shutting down', async function () {\n      // make a command that will wait a bit so we can crash while it's running\n      sandbox.stub(d, 'deleteSession').callsFake(async function () {\n        await B.delay(100);\n        DriverClass.prototype.deleteSession.call(this);\n      });\n\n      await d.createSession(_.cloneDeep(w3cCaps));\n      const p = 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('We crashed'));\n      await p;\n\n      await d.executeCommand('getSession').should.be.rejectedWith(/shut down/);\n      await B.delay(500);\n\n      await d.executeCommand('createSession', null, null, _.cloneDeep(w3cCaps));\n      await d.deleteSession();\n    });\n\n    it('should distinguish between W3C and JSONWP session', async function () {\n      // Test W3C (leave first 2 args null because those are the JSONWP args)\n      await d.executeCommand('createSession', null, null, {\n        alwaysMatch: {\n          ...defaultCaps,\n          platformName: 'Fake',\n          'appium:deviceName': 'Commodore 64',\n        },\n        firstMatch: [{}],\n      });\n\n      expect(d.protocol).to.equal('W3C');\n    });\n\n    describe('protocol detection', function () {\n      it('should use W3C if only W3C caps are provided', async function () {\n        await d.createSession({\n          alwaysMatch: _.clone(defaultCaps),\n          firstMatch: [{}],\n        });\n        expect(d.protocol).to.equal('W3C');\n      });\n    });\n\n    it('should have a method to get driver for a session', async function () {\n      let [sessId] = await d.createSession(w3cCaps);\n      expect(d.driverForSession(sessId)).to.eql(d);\n    });\n\n    describe('command queue', function () {\n      /** @type {InstanceType<DriverClass>} */\n      let d;\n      let waitMs = 10;\n\n      beforeEach(function () {\n        d = new DriverClass();\n        sandbox.stub(d, 'getStatus').callsFake(async () => {\n          await B.delay(waitMs);\n          return Date.now();\n        });\n        sandbox.stub(d, 'getSessions').callsFake(async () => {\n          await B.delay(waitMs);\n          throw new Error('multipass');\n        });\n      });\n\n      afterEach(async function () {\n        await d.clearNewCommandTimeout();\n      });\n\n      it('should queue commands and.executeCommand/respond in the order received', async function () {\n        let numCmds = 10;\n        let cmds = [];\n        for (let i = 0; i < numCmds; i++) {\n          cmds.push(d.executeCommand('getStatus'));\n        }\n        let results = await B.all(cmds);\n        for (let i = 1; i < numCmds; i++) {\n          if (results[i] <= results[i - 1]) {\n            throw new Error('Got result out of order');\n          }\n        }\n      });\n\n      it('should handle errors correctly when queuing', async function () {\n        let numCmds = 10;\n        let cmds = [];\n        for (let i = 0; i < numCmds; i++) {\n          if (i === 5) {\n            cmds.push(d.executeCommand('getSessions'));\n          } else {\n            cmds.push(d.executeCommand('getStatus'));\n          }\n        }\n        let results = /** @type {PromiseFulfilledResult<any>[]} */ (\n          // eslint-disable-next-line promise/no-native\n          await Promise.allSettled(cmds)\n        );\n        for (let i = 1; i < 5; i++) {\n          if (results[i].value <= results[i - 1].value) {\n            throw new Error('Got result out of order');\n          }\n        }\n        /** @type {PromiseRejectedResult} */ (\n          /** @type {unknown} */ (results[5])\n        ).reason.message.should.contain('multipass');\n        for (let i = 7; i < numCmds; i++) {\n          if (results[i].value <= results[i - 1].value) {\n            throw new Error('Got result out of order');\n          }\n        }\n      });\n\n      it('should not care if queue empties for a bit', async function () {\n        let numCmds = 10;\n        let cmds = [];\n        for (let i = 0; i < numCmds; i++) {\n          cmds.push(d.executeCommand('getStatus'));\n        }\n        let results = await B.all(cmds);\n        cmds = [];\n        for (let i = 0; i < numCmds; i++) {\n          cmds.push(d.executeCommand('getStatus'));\n        }\n        results = await B.all(cmds);\n        for (let i = 1; i < numCmds; i++) {\n          if (results[i] <= results[i - 1]) {\n            throw new Error('Got result out of order');\n          }\n        }\n      });\n    });\n\n    describe('timeouts', function () {\n      before(async function () {\n        await d.createSession(w3cCaps);\n      });\n      describe('command', function () {\n        it('should exist by default', function () {\n          d.newCommandTimeoutMs.should.equal(60000);\n        });\n        it('should be settable through `timeouts`', async function () {\n          await d.timeouts('command', 20);\n          d.newCommandTimeoutMs.should.equal(20);\n        });\n      });\n      describe('implicit', function () {\n        it('should not exist by default', function () {\n          d.implicitWaitMs.should.equal(0);\n        });\n        it('should be settable through `timeouts`', async function () {\n          await d.timeouts('implicit', 20);\n          d.implicitWaitMs.should.equal(20);\n        });\n      });\n    });\n\n    describe('timeouts (W3C)', function () {\n      beforeEach(async function () {\n        await d.createSession(w3cCaps);\n      });\n      afterEach(async function () {\n        await d.deleteSession();\n      });\n      it('should get timeouts that we set', async function () {\n        // @ts-expect-error\n        await d.timeouts(undefined, undefined, undefined, undefined, 1000);\n        await d.getTimeouts().should.eventually.have.property('implicit', 1000);\n        await d.timeouts('command', 2000);\n        await d.getTimeouts().should.eventually.deep.equal({\n          implicit: 1000,\n          command: 2000,\n        });\n        // @ts-expect-error\n        await d.timeouts(undefined, undefined, undefined, undefined, 3000);\n        await d.getTimeouts().should.eventually.deep.equal({\n          implicit: 3000,\n          command: 2000,\n        });\n      });\n    });\n\n    describe('reset compatibility', function () {\n      it('should not allow both fullReset and noReset to be true', async function () {\n        const newCaps = {\n          alwaysMatch: {\n            ...defaultCaps,\n            platformName: 'Fake',\n            'appium:deviceName': 'Commodore 64',\n            'appium:fullReset': true,\n            'appium:noReset': true,\n          },\n          firstMatch: [{}],\n        };\n        await d.createSession(newCaps).should.be.rejectedWith(/noReset.+fullReset/);\n      });\n    });\n\n    describe('proxying', function () {\n      let sessId;\n      beforeEach(async function () {\n        [sessId] = await d.createSession(w3cCaps);\n      });\n      describe('#proxyActive', function () {\n        it('should exist', function () {\n          d.proxyActive.should.be.an.instanceof(Function);\n        });\n        it('should return false', function () {\n          d.proxyActive(sessId).should.be.false;\n        });\n        it('should throw an error when sessionId is wrong', function () {\n          (() => {\n            d.proxyActive('aaa');\n          }).should.throw;\n        });\n      });\n\n      describe('#getProxyAvoidList', function () {\n        it('should exist', function () {\n          d.getProxyAvoidList.should.be.an.instanceof(Function);\n        });\n        it('should return an array', function () {\n          d.getProxyAvoidList(sessId).should.be.an.instanceof(Array);\n        });\n        it('should throw an error when sessionId is wrong', function () {\n          (() => {\n            d.getProxyAvoidList('aaa');\n          }).should.throw;\n        });\n      });\n\n      describe('#canProxy', function () {\n        it('should have a #canProxy method', function () {\n          d.canProxy.should.be.an.instanceof(Function);\n        });\n        it('should return a boolean from #canProxy', function () {\n          d.canProxy(sessId).should.be.a('boolean');\n        });\n        it('should throw an error when sessionId is wrong', function () {\n          (() => {\n            d.canProxy();\n          }).should.throw;\n        });\n      });\n\n      describe('#proxyRouteIsAvoided', function () {\n        it('should validate form of avoidance list', function () {\n          const avoidStub = sandbox.stub(d, 'getProxyAvoidList');\n          // @ts-expect-error\n          avoidStub.returns([['POST', /\\/foo/], ['GET']]);\n          (() => {\n            // @ts-expect-error\n            d.proxyRouteIsAvoided();\n          }).should.throw;\n          avoidStub.returns([\n            ['POST', /\\/foo/],\n            // @ts-expect-error\n            ['GET', /^foo/, 'bar'],\n          ]);\n          (() => {\n            // @ts-expect-error\n            d.proxyRouteIsAvoided();\n          }).should.throw;\n        });\n        it('should reject bad http methods', function () {\n          const avoidStub = sandbox.stub(d, 'getProxyAvoidList');\n          avoidStub.returns([\n            ['POST', /^foo/],\n            // @ts-expect-error\n            ['BAZETE', /^bar/],\n          ]);\n          (() => {\n            // @ts-expect-error\n            d.proxyRouteIsAvoided();\n          }).should.throw;\n        });\n        it('should reject non-regex routes', function () {\n          const avoidStub = sandbox.stub(d, 'getProxyAvoidList');\n          avoidStub.returns([\n            ['POST', /^foo/],\n            // @ts-expect-error\n            ['GET', '/bar'],\n          ]);\n          (() => {\n            // @ts-expect-error\n            d.proxyRouteIsAvoided();\n          }).should.throw;\n        });\n        it('should return true for routes in the avoid list', function () {\n          const avoidStub = sandbox.stub(d, 'getProxyAvoidList');\n          avoidStub.returns([['POST', /^\\/foo/]]);\n          d.proxyRouteIsAvoided('foo', 'POST', '/foo/bar').should.be.true;\n        });\n        it('should strip away any wd/hub prefix', function () {\n          const avoidStub = sandbox.stub(d, 'getProxyAvoidList');\n          avoidStub.returns([['POST', /^\\/foo/]]);\n          d.proxyRouteIsAvoided('foo', 'POST', '/foo/bar').should.be.true;\n        });\n        it('should return false for routes not in the avoid list', function () {\n          const avoidStub = sandbox.stub(d, 'getProxyAvoidList');\n          avoidStub.returns([['POST', /^\\/foo/]]);\n          d.proxyRouteIsAvoided('foo', 'GET', '/foo/bar').should.be.false;\n          d.proxyRouteIsAvoided('foo', 'POST', '/boo').should.be.false;\n        });\n      });\n    });\n\n    describe('event timing framework', function () {\n      let beforeStartTime;\n      beforeEach(async function () {\n        beforeStartTime = Date.now();\n        d.shouldValidateCaps = false;\n        await d.executeCommand('createSession', null, null, {\n          alwaysMatch: {...defaultCaps},\n          firstMatch: [{}],\n        });\n      });\n      describe('#eventHistory', function () {\n        it('should have an eventHistory property', function () {\n          should.exist(d.eventHistory);\n          should.exist(d.eventHistory.commands);\n        });\n\n        it('should have a session start timing after session start', function () {\n          let {newSessionRequested, newSessionStarted} = d.eventHistory;\n          newSessionRequested.should.have.length(1);\n          newSessionStarted.should.have.length(1);\n          newSessionRequested[0].should.be.a('number');\n          newSessionStarted[0].should.be.a('number');\n          (newSessionRequested[0] >= beforeStartTime).should.be.true;\n          (newSessionStarted[0] >= newSessionRequested[0]).should.be.true;\n        });\n\n        it('should include a commands list', async function () {\n          await d.executeCommand('getStatus', []);\n          d.eventHistory.commands.length.should.equal(2);\n          d.eventHistory.commands[1].cmd.should.equal('getStatus');\n          d.eventHistory.commands[1].startTime.should.be.a('number');\n          d.eventHistory.commands[1].endTime.should.be.a('number');\n        });\n      });\n      describe('#logEvent', function () {\n        it('should allow logging arbitrary events', function () {\n          d.logEvent('foo');\n          d.eventHistory.foo[0].should.be.a('number');\n          (d.eventHistory.foo[0] >= beforeStartTime).should.be.true;\n        });\n        it('should not allow reserved or oddly formed event names', function () {\n          (() => {\n            d.logEvent('commands');\n          }).should.throw();\n          (() => {\n            // @ts-expect-error\n            d.logEvent(1);\n          }).should.throw();\n          (() => {\n            // @ts-expect-error\n            d.logEvent({});\n          }).should.throw();\n        });\n      });\n      it('should allow logging the same event multiple times', function () {\n        d.logEvent('bar');\n        d.logEvent('bar');\n        d.eventHistory.bar.should.have.length(2);\n        d.eventHistory.bar[1].should.be.a('number');\n        (d.eventHistory.bar[1] >= d.eventHistory.bar[0]).should.be.true;\n      });\n      describe('getSession decoration', function () {\n        it('should decorate getSession response if opt-in cap is provided', async function () {\n          let res = await d.getSession();\n          should.not.exist(res.events);\n\n          _.set(d, 'caps.eventTimings', true);\n          res = await d.getSession();\n          should.exist(res.events);\n          should.exist(res.events?.newSessionRequested);\n          expect(res.events?.newSessionRequested[0]).to.be.a('number');\n        });\n      });\n    });\n    describe('.reset', function () {\n      it('should reset as W3C if the original session was W3C', async function () {\n        const caps = {\n          alwaysMatch: {\n            'appium:app': 'Fake',\n            'appium:deviceName': 'Fake',\n            'appium:automationName': 'Fake',\n            platformName: 'Fake',\n            ...defaultCaps,\n          },\n\n          firstMatch: [{}],\n        };\n        await d.createSession(caps);\n        expect(d.protocol).to.equal('W3C');\n        await d.reset();\n        expect(d.protocol).to.equal('W3C');\n      });\n    });\n  });\n\n  describe('.isFeatureEnabled', function () {\n    let d;\n\n    beforeEach(function () {\n      d = new DriverClass();\n    });\n\n    it('should say a feature is enabled when it is explicitly allowed', function () {\n      d.allowInsecure = ['foo', 'bar'];\n      d.isFeatureEnabled('foo').should.be.true;\n      d.isFeatureEnabled('bar').should.be.true;\n      d.isFeatureEnabled('baz').should.be.false;\n    });\n\n    it('should say a feature is not enabled if it is not enabled', function () {\n      d.allowInsecure = [];\n      d.isFeatureEnabled('foo').should.be.false;\n    });\n\n    it('should prefer denyInsecure to allowInsecure', function () {\n      d.allowInsecure = ['foo', 'bar'];\n      d.denyInsecure = ['foo'];\n      d.isFeatureEnabled('foo').should.be.false;\n      d.isFeatureEnabled('bar').should.be.true;\n      d.isFeatureEnabled('baz').should.be.false;\n    });\n\n    it('should allow global setting for insecurity', function () {\n      d.relaxedSecurityEnabled = true;\n      d.isFeatureEnabled('foo').should.be.true;\n      d.isFeatureEnabled('bar').should.be.true;\n      d.isFeatureEnabled('baz').should.be.true;\n    });\n\n    it('global setting should be overrideable', function () {\n      d.relaxedSecurityEnabled = true;\n      d.denyInsecure = ['foo', 'bar'];\n      d.isFeatureEnabled('foo').should.be.false;\n      d.isFeatureEnabled('bar').should.be.false;\n      d.isFeatureEnabled('baz').should.be.true;\n    });\n  });\n}\n\n/**\n * @typedef {import('@appium/types').DriverClass} DriverClass\n * @typedef {import('@appium/types').W3CCapabilities} W3CCapabilities\n * @typedef {import('@appium/types').AppiumW3CCapabilities} AppiumW3CCapabilities\n */\n"],"mappings":"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"}