appium 2.0.0-beta.20 → 2.0.0-beta.24

package/build/test/driver-specs.js

@@ -0,0 +1,386 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _baseDriver = require("@appium/base-driver");
+
+var _fakeDriver = require("@appium/fake-driver");
+
+var _asyncbox = require("asyncbox");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+var _appium = require("../lib/appium");
+
+var _schema = require("../lib/schema/schema");
+
+var _utils = require("../lib/utils");
+
+var _helpers = require("./helpers");
+
+const SESSION_ID = 1;
+describe('AppiumDriver', function () {
+  beforeEach(function () {
+    (0, _schema.resetSchema)();
+    (0, _schema.finalizeSchema)();
+  });
+  describe('instance method', function () {
+    function getDriverAndFakeDriver(appiumArgs = {}, DriverClass = _fakeDriver.FakeDriver) {
+      const appium = new _appium.AppiumDriver(appiumArgs);
+      const fakeDriver = new DriverClass();
+
+      const mockFakeDriver = _sinon.default.mock(fakeDriver);
+
+      mockFakeDriver._fakeDriver = fakeDriver;
+
+      const mockedDriverReturnerClass = function Driver() {
+        return fakeDriver;
+      };
+
+      appium._findMatchingDriver = function () {
+        return {
+          driver: mockedDriverReturnerClass,
+          version: '1.2.3',
+          driverName: 'fake'
+        };
+      };
+
+      return [appium, mockFakeDriver];
+    }
+
+    describe('createSession', function () {
+      let appium;
+      let mockFakeDriver;
+      beforeEach(function () {
+        [appium, mockFakeDriver] = getDriverAndFakeDriver();
+      });
+      afterEach(async function () {
+        mockFakeDriver.restore();
+        await appium.deleteSession(SESSION_ID);
+      });
+      it(`should call inner driver's createSession with desired capabilities`, async function () {
+        mockFakeDriver.expects('createSession').once().withExactArgs(null, null, _helpers.W3C_CAPS, []).returns([SESSION_ID, (0, _utils.removeAppiumPrefixes)(_helpers.W3C_PREFIXED_CAPS)]);
+        await appium.createSession(null, null, _helpers.W3C_CAPS);
+        mockFakeDriver.verify();
+      });
+      it(`should call inner driver's createSession with desired and default capabilities`, async function () {
+        let defaultCaps = {
+          'appium:someCap': 'hello'
+        };
+        let allCaps = { ..._helpers.W3C_CAPS,
+          alwaysMatch: { ..._helpers.W3C_CAPS.alwaysMatch,
+            ...defaultCaps
+          }
+        };
+        appium.args.defaultCapabilities = defaultCaps;
+        mockFakeDriver.expects('createSession').once().withArgs(null, null, allCaps).returns([SESSION_ID, (0, _utils.removeAppiumPrefixes)(allCaps.alwaysMatch)]);
+        await appium.createSession(null, null, _helpers.W3C_CAPS);
+        mockFakeDriver.verify();
+      });
+      it(`should call inner driver's createSession with desired and default capabilities without overriding caps`, async function () {
+        let defaultCaps = {
+          platformName: 'Ersatz'
+        };
+        appium.args.defaultCapabilities = defaultCaps;
+        mockFakeDriver.expects('createSession').once().withArgs(null, null, _helpers.W3C_CAPS).returns([SESSION_ID, (0, _utils.removeAppiumPrefixes)(_helpers.W3C_PREFIXED_CAPS)]);
+        await appium.createSession(null, null, _helpers.W3C_CAPS);
+        mockFakeDriver.verify();
+      });
+      it('should kill all other sessions if sessionOverride is on', async function () {
+        appium.args.sessionOverride = true;
+        let fakeDrivers = [new _fakeDriver.FakeDriver(), new _fakeDriver.FakeDriver(), new _fakeDriver.FakeDriver()];
+
+        let mockFakeDrivers = _lodash.default.map(fakeDrivers, fd => _sinon.default.mock(fd));
+
+        mockFakeDrivers[0].expects('deleteSession').once();
+        mockFakeDrivers[1].expects('deleteSession').once().throws('Cannot shut down Android driver; it has already shut down');
+        mockFakeDrivers[2].expects('deleteSession').once();
+        appium.sessions['abc-123-xyz'] = fakeDrivers[0];
+        appium.sessions['xyz-321-abc'] = fakeDrivers[1];
+        appium.sessions['123-abc-xyz'] = fakeDrivers[2];
+        let sessions = await appium.getSessions();
+        sessions.should.have.length(3);
+        mockFakeDriver.expects('createSession').once().withExactArgs(null, null, _helpers.W3C_CAPS, []).returns([SESSION_ID, (0, _utils.removeAppiumPrefixes)(_helpers.W3C_PREFIXED_CAPS)]);
+        await appium.createSession(null, null, _helpers.W3C_CAPS);
+        sessions = await appium.getSessions();
+        sessions.should.have.length(1);
+
+        for (let mfd of mockFakeDrivers) {
+          mfd.verify();
+        }
+
+        mockFakeDriver.verify();
+      });
+      it('should call "createSession" with W3C capabilities argument, if provided', async function () {
+        mockFakeDriver.expects('createSession').once().withArgs(null, undefined, _helpers.W3C_CAPS).returns([SESSION_ID, _helpers.BASE_CAPS]);
+        await appium.createSession(undefined, undefined, _helpers.W3C_CAPS);
+        mockFakeDriver.verify();
+      });
+      it('should call "createSession" with W3C capabilities argument with additional provided parameters', async function () {
+        let w3cCaps = { ..._helpers.W3C_CAPS,
+          alwaysMatch: { ..._helpers.W3C_CAPS.alwaysMatch,
+            'appium:someOtherParm': 'someOtherParm'
+          }
+        };
+        mockFakeDriver.expects('createSession').once().withArgs(null, undefined, {
+          alwaysMatch: { ...w3cCaps.alwaysMatch,
+            'appium:someOtherParm': 'someOtherParm'
+          },
+          firstMatch: [{}]
+        }).returns([SESSION_ID, (0, _utils.insertAppiumPrefixes)(_helpers.BASE_CAPS)]);
+        await appium.createSession(undefined, undefined, w3cCaps);
+        mockFakeDriver.verify();
+      });
+      it('should not call "createSession" with JSONWP capabilities if W3C has incomplete capabilities', async function () {
+        const w3cCaps = { ..._helpers.W3C_CAPS,
+          alwaysMatch: {
+            'appium:someOtherParm': 'someOtherParm'
+          }
+        };
+        const jsonwpCaps = { ..._helpers.BASE_CAPS,
+          automationName: 'Fake',
+          someOtherParam: 'someOtherParam'
+        };
+        mockFakeDriver.expects('createSession').never();
+        await appium.createSession(jsonwpCaps, undefined, w3cCaps);
+        mockFakeDriver.verify();
+      });
+      it('should assign args to property `cliArgs`', async function () {
+        class ArgsDriver extends _baseDriver.BaseDriver {}
+
+        const args = {
+          driver: {
+            fake: {
+              randomArg: 1234
+            }
+          }
+        };
+        [appium, mockFakeDriver] = getDriverAndFakeDriver(args, ArgsDriver);
+        const {
+          value
+        } = await appium.createSession(undefined, undefined, _helpers.W3C_CAPS);
+
+        try {
+          mockFakeDriver._fakeDriver.cliArgs.should.eql({
+            randomArg: 1234
+          });
+        } finally {
+          await appium.deleteSession(value[0]);
+        }
+      });
+    });
+    describe('deleteSession', function () {
+      let appium;
+      let mockFakeDriver;
+      beforeEach(function () {
+        [appium, mockFakeDriver] = getDriverAndFakeDriver();
+      });
+      afterEach(function () {
+        mockFakeDriver.restore();
+      });
+      it('should remove the session if it is found', async function () {
+        let [sessionId] = (await appium.createSession(null, null, _helpers.W3C_CAPS)).value;
+        let sessions = await appium.getSessions();
+        sessions.should.have.length(1);
+        await appium.deleteSession(sessionId);
+        sessions = await appium.getSessions();
+        sessions.should.have.length(0);
+      });
+      it('should call inner driver\'s deleteSession method', async function () {
+        const [sessionId] = (await appium.createSession(null, null, _helpers.W3C_CAPS)).value;
+        mockFakeDriver.expects('deleteSession').once().withExactArgs(sessionId, []).returns();
+        await appium.deleteSession(sessionId);
+        mockFakeDriver.verify();
+        await mockFakeDriver.object.deleteSession();
+      });
+    });
+    describe('getSessions', function () {
+      let appium, mockFakeDriver;
+      let sessions;
+      before(function () {
+        [appium, mockFakeDriver] = getDriverAndFakeDriver();
+      });
+      afterEach(async function () {
+        for (let session of sessions) {
+          await appium.deleteSession(session.id);
+        }
+
+        mockFakeDriver.restore();
+      });
+      it('should return an empty array of sessions', async function () {
+        sessions = await appium.getSessions();
+        sessions.should.be.an('array');
+        sessions.should.be.empty;
+      });
+      it('should return sessions created', async function () {
+        let caps1 = {
+          alwaysMatch: { ..._helpers.W3C_PREFIXED_CAPS,
+            'appium:cap': 'value'
+          }
+        };
+        let caps2 = {
+          alwaysMatch: { ..._helpers.W3C_PREFIXED_CAPS,
+            'appium:cap': 'other value'
+          }
+        };
+        mockFakeDriver.expects('createSession').once().returns(['fake-session-id-1', (0, _utils.removeAppiumPrefixes)(caps1.alwaysMatch)]);
+        let [session1Id, session1Caps] = (await appium.createSession(null, null, caps1)).value;
+        mockFakeDriver.expects('createSession').once().returns(['fake-session-id-2', (0, _utils.removeAppiumPrefixes)(caps2.alwaysMatch)]);
+        let [session2Id, session2Caps] = (await appium.createSession(null, null, caps2)).value;
+        sessions = await appium.getSessions();
+        sessions.should.be.an('array');
+        sessions.should.have.length(2);
+        sessions[0].id.should.equal(session1Id);
+        (0, _utils.removeAppiumPrefixes)(caps1.alwaysMatch).should.eql(session1Caps);
+        sessions[1].id.should.equal(session2Id);
+        (0, _utils.removeAppiumPrefixes)(caps2.alwaysMatch).should.eql(session2Caps);
+      });
+    });
+    describe('getStatus', function () {
+      let appium;
+      before(function () {
+        appium = new _appium.AppiumDriver({});
+      });
+      it('should return a status', async function () {
+        let status = await appium.getStatus();
+        status.build.should.exist;
+        status.build.version.should.exist;
+      });
+    });
+    describe('sessionExists', function () {});
+    describe('attachUnexpectedShutdownHandler', function () {
+      let appium;
+      let mockFakeDriver;
+      beforeEach(function () {
+        [appium, mockFakeDriver] = getDriverAndFakeDriver();
+      });
+      afterEach(async function () {
+        await mockFakeDriver.object.deleteSession();
+        mockFakeDriver.restore();
+        appium.args.defaultCapabilities = {};
+      });
+      it('should remove session if inner driver unexpectedly exits with an error', async function () {
+        let [sessionId] = (await appium.createSession(null, null, _lodash.default.clone(_helpers.W3C_CAPS))).value;
+
+        _lodash.default.keys(appium.sessions).should.contain(sessionId);
+
+        appium.sessions[sessionId].eventEmitter.emit('onUnexpectedShutdown', new Error('Oops'));
+        await (0, _asyncbox.sleep)(1);
+
+        _lodash.default.keys(appium.sessions).should.not.contain(sessionId);
+      });
+      it('should remove session if inner driver unexpectedly exits with no error', async function () {
+        let [sessionId] = (await appium.createSession(null, null, _lodash.default.clone(_helpers.W3C_CAPS))).value;
+
+        _lodash.default.keys(appium.sessions).should.contain(sessionId);
+
+        appium.sessions[sessionId].eventEmitter.emit('onUnexpectedShutdown');
+        await (0, _asyncbox.sleep)(1);
+
+        _lodash.default.keys(appium.sessions).should.not.contain(sessionId);
+      });
+    });
+    describe('createPluginInstances', function () {
+      class NoArgsPlugin {}
+
+      NoArgsPlugin.pluginName = 'noargs';
+
+      class ArgsPlugin {}
+
+      ArgsPlugin.pluginName = 'args';
+
+      class ArrayArgPlugin {}
+
+      ArrayArgPlugin.pluginName = 'arrayarg';
+      beforeEach(function () {
+        (0, _schema.resetSchema)();
+        (0, _schema.registerSchema)('plugin', ArgsPlugin.pluginName, {
+          type: 'object',
+          properties: {
+            randomArg: {
+              type: 'number',
+              default: 2000
+            }
+          }
+        });
+        (0, _schema.registerSchema)('plugin', ArrayArgPlugin.pluginName, {
+          type: 'object',
+          properties: {
+            arr: {
+              type: 'array',
+              default: []
+            }
+          }
+        });
+        (0, _schema.finalizeSchema)();
+      });
+      describe('when args are not present', function () {
+        it('should not set CLI args', function () {
+          const appium = new _appium.AppiumDriver({});
+          appium.pluginClasses = [NoArgsPlugin, ArgsPlugin];
+
+          for (const plugin of appium.createPluginInstances()) {
+            should.not.exist(plugin.cliArgs);
+          }
+        });
+      });
+      describe('when args are equal to the schema defaults', function () {
+        it('should not set CLI args', function () {
+          const appium = new _appium.AppiumDriver({
+            plugin: {
+              [ArgsPlugin.pluginName]: {
+                randomArg: 2000
+              }
+            }
+          });
+          appium.pluginClasses = [NoArgsPlugin, ArgsPlugin];
+
+          for (const plugin of appium.createPluginInstances()) {
+            should.not.exist(plugin.cliArgs);
+          }
+        });
+        describe('when the default is an "object"', function () {
+          it('should not set CLI args', function () {
+            const appium = new _appium.AppiumDriver({
+              plugin: {
+                [ArrayArgPlugin.pluginName]: {
+                  arr: []
+                }
+              }
+            });
+            appium.pluginClasses = [NoArgsPlugin, ArgsPlugin, ArrayArgPlugin];
+
+            for (const plugin of appium.createPluginInstances()) {
+              should.not.exist(plugin.cliArgs);
+            }
+          });
+        });
+      });
+      describe('when args are not equal to the schema defaults', function () {
+        it('should add cliArgs to the plugin', function () {
+          const appium = new _appium.AppiumDriver({
+            plugin: {
+              args: {
+                randomArg: 1234
+              }
+            }
+          });
+          appium.pluginClasses = [ArgsPlugin];
+
+          const plugin = _lodash.default.first(appium.createPluginInstances());
+
+          plugin.cliArgs.should.eql({
+            randomArg: 1234
+          });
+        });
+      });
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/driver-specs.js"],"names":["SESSION_ID","describe","beforeEach","getDriverAndFakeDriver","appiumArgs","DriverClass","FakeDriver","appium","AppiumDriver","fakeDriver","mockFakeDriver","sinon","mock","_fakeDriver","mockedDriverReturnerClass","Driver","_findMatchingDriver","driver","version","driverName","afterEach","restore","deleteSession","it","expects","once","withExactArgs","W3C_CAPS","returns","W3C_PREFIXED_CAPS","createSession","verify","defaultCaps","allCaps","alwaysMatch","args","defaultCapabilities","withArgs","platformName","sessionOverride","fakeDrivers","mockFakeDrivers","_","map","fd","throws","sessions","getSessions","should","have","length","mfd","undefined","BASE_CAPS","w3cCaps","firstMatch","jsonwpCaps","automationName","someOtherParam","never","ArgsDriver","BaseDriver","fake","randomArg","value","cliArgs","eql","sessionId","object","before","session","id","be","an","empty","caps1","caps2","session1Id","session1Caps","session2Id","session2Caps","equal","status","getStatus","build","exist","clone","keys","contain","eventEmitter","emit","Error","not","NoArgsPlugin","pluginName","ArgsPlugin","ArrayArgPlugin","type","properties","default","arr","pluginClasses","plugin","createPluginInstances","first"],"mappings":";;;;;;AAEA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAGA,MAAMA,UAAU,GAAG,CAAnB;AAEAC,QAAQ,CAAC,cAAD,EAAiB,YAAY;AACnCC,EAAAA,UAAU,CAAC,YAAY;AACrB;AACA;AACD,GAHS,CAAV;AAIAD,EAAAA,QAAQ,CAAC,iBAAD,EAAoB,YAAY;AACtC,aAASE,sBAAT,CAAiCC,UAAU,GAAG,EAA9C,EAAkDC,WAAW,GAAGC,sBAAhE,EAA4E;AAC1E,YAAMC,MAAM,GAAG,IAAIC,oBAAJ,CAAiBJ,UAAjB,CAAf;AACA,YAAMK,UAAU,GAAG,IAAIJ,WAAJ,EAAnB;;AACA,YAAMK,cAAc,GAAGC,eAAMC,IAAN,CAAWH,UAAX,CAAvB;;AACAC,MAAAA,cAAc,CAACG,WAAf,GAA6BJ,UAA7B;;AACA,YAAMK,yBAAyB,GAAG,SAASC,MAAT,GAAmB;AACnD,eAAON,UAAP;AACD,OAFD;;AAIAF,MAAAA,MAAM,CAACS,mBAAP,GAA6B,YAAY;AACvC,eAAO;AACLC,UAAAA,MAAM,EAAEH,yBADH;AAELI,UAAAA,OAAO,EAAE,OAFJ;AAGLC,UAAAA,UAAU,EAAE;AAHP,SAAP;AAKD,OAND;;AAOA,aAAO,CAACZ,MAAD,EAASG,cAAT,CAAP;AACD;;AACDT,IAAAA,QAAQ,CAAC,eAAD,EAAkB,YAAY;AACpC,UAAIM,MAAJ;AACA,UAAIG,cAAJ;AACAR,MAAAA,UAAU,CAAC,YAAY;AACrB,SAACK,MAAD,EAASG,cAAT,IAA2BP,sBAAsB,EAAjD;AACD,OAFS,CAAV;AAGAiB,MAAAA,SAAS,CAAC,kBAAkB;AAC1BV,QAAAA,cAAc,CAACW,OAAf;AACA,cAAMd,MAAM,CAACe,aAAP,CAAqBtB,UAArB,CAAN;AACD,OAHQ,CAAT;AAKAuB,MAAAA,EAAE,CAAE,oEAAF,EAAuE,kBAAkB;AACzFb,QAAAA,cAAc,CAACc,OAAf,CAAuB,eAAvB,EACGC,IADH,GACUC,aADV,CACwB,IADxB,EAC8B,IAD9B,EACoCC,iBADpC,EAC8C,EAD9C,EAEGC,OAFH,CAEW,CAAC5B,UAAD,EAAa,iCAAqB6B,0BAArB,CAAb,CAFX;AAGA,cAAMtB,MAAM,CAACuB,aAAP,CAAqB,IAArB,EAA2B,IAA3B,EAAiCH,iBAAjC,CAAN;AACAjB,QAAAA,cAAc,CAACqB,MAAf;AACD,OANC,CAAF;AAOAR,MAAAA,EAAE,CAAE,gFAAF,EAAmF,kBAAkB;AACrG,YAAIS,WAAW,GAAG;AAAC,4BAAkB;AAAnB,SAAlB;AACA,YAAIC,OAAO,GAAG,EAAC,GAAGN,iBAAJ;AAAcO,UAAAA,WAAW,EAAE,EAAC,GAAGP,kBAASO,WAAb;AAA0B,eAAGF;AAA7B;AAA3B,SAAd;AACAzB,QAAAA,MAAM,CAAC4B,IAAP,CAAYC,mBAAZ,GAAkCJ,WAAlC;AACAtB,QAAAA,cAAc,CAACc,OAAf,CAAuB,eAAvB,EACGC,IADH,GACUY,QADV,CACmB,IADnB,EACyB,IADzB,EAC+BJ,OAD/B,EAEGL,OAFH,CAEW,CAAC5B,UAAD,EAAa,iCAAqBiC,OAAO,CAACC,WAA7B,CAAb,CAFX;AAGA,cAAM3B,MAAM,CAACuB,aAAP,CAAqB,IAArB,EAA2B,IAA3B,EAAiCH,iBAAjC,CAAN;AACAjB,QAAAA,cAAc,CAACqB,MAAf;AACD,OATC,CAAF;AAUAR,MAAAA,EAAE,CAAE,wGAAF,EAA2G,kBAAkB;AAG7H,YAAIS,WAAW,GAAG;AAACM,UAAAA,YAAY,EAAE;AAAf,SAAlB;AACA/B,QAAAA,MAAM,CAAC4B,IAAP,CAAYC,mBAAZ,GAAkCJ,WAAlC;AACAtB,QAAAA,cAAc,CAACc,OAAf,CAAuB,eAAvB,EACGC,IADH,GACUY,QADV,CACmB,IADnB,EACyB,IADzB,EAC+BV,iBAD/B,EAEGC,OAFH,CAEW,CAAC5B,UAAD,EAAa,iCAAqB6B,0BAArB,CAAb,CAFX;AAGA,cAAMtB,MAAM,CAACuB,aAAP,CAAqB,IAArB,EAA2B,IAA3B,EAAiCH,iBAAjC,CAAN;AACAjB,QAAAA,cAAc,CAACqB,MAAf;AACD,OAVC,CAAF;AAWAR,MAAAA,EAAE,CAAC,yDAAD,EAA4D,kBAAkB;AAC9EhB,QAAAA,MAAM,CAAC4B,IAAP,CAAYI,eAAZ,GAA8B,IAA9B;AAGA,YAAIC,WAAW,GAAG,CAChB,IAAIlC,sBAAJ,EADgB,EAEhB,IAAIA,sBAAJ,EAFgB,EAGhB,IAAIA,sBAAJ,EAHgB,CAAlB;;AAKA,YAAImC,eAAe,GAAGC,gBAAEC,GAAF,CAAMH,WAAN,EAAoBI,EAAD,IAAQjC,eAAMC,IAAN,CAAWgC,EAAX,CAA3B,CAAtB;;AACAH,QAAAA,eAAe,CAAC,CAAD,CAAf,CAAmBjB,OAAnB,CAA2B,eAA3B,EACGC,IADH;AAEAgB,QAAAA,eAAe,CAAC,CAAD,CAAf,CAAmBjB,OAAnB,CAA2B,eAA3B,EACGC,IADH,GAEGoB,MAFH,CAEU,2DAFV;AAGAJ,QAAAA,eAAe,CAAC,CAAD,CAAf,CAAmBjB,OAAnB,CAA2B,eAA3B,EACGC,IADH;AAEAlB,QAAAA,MAAM,CAACuC,QAAP,CAAgB,aAAhB,IAAiCN,WAAW,CAAC,CAAD,CAA5C;AACAjC,QAAAA,MAAM,CAACuC,QAAP,CAAgB,aAAhB,IAAiCN,WAAW,CAAC,CAAD,CAA5C;AACAjC,QAAAA,MAAM,CAACuC,QAAP,CAAgB,aAAhB,IAAiCN,WAAW,CAAC,CAAD,CAA5C;AAEA,YAAIM,QAAQ,GAAG,MAAMvC,MAAM,CAACwC,WAAP,EAArB;AACAD,QAAAA,QAAQ,CAACE,MAAT,CAAgBC,IAAhB,CAAqBC,MAArB,CAA4B,CAA5B;AAEAxC,QAAAA,cAAc,CAACc,OAAf,CAAuB,eAAvB,EACGC,IADH,GACUC,aADV,CACwB,IADxB,EAC8B,IAD9B,EACoCC,iBADpC,EAC8C,EAD9C,EAEGC,OAFH,CAEW,CAAC5B,UAAD,EAAa,iCAAqB6B,0BAArB,CAAb,CAFX;AAGA,cAAMtB,MAAM,CAACuB,aAAP,CAAqB,IAArB,EAA2B,IAA3B,EAAiCH,iBAAjC,CAAN;AAEAmB,QAAAA,QAAQ,GAAG,MAAMvC,MAAM,CAACwC,WAAP,EAAjB;AACAD,QAAAA,QAAQ,CAACE,MAAT,CAAgBC,IAAhB,CAAqBC,MAArB,CAA4B,CAA5B;;AAEA,aAAK,IAAIC,GAAT,IAAgBV,eAAhB,EAAiC;AAC/BU,UAAAA,GAAG,CAACpB,MAAJ;AACD;;AACDrB,QAAAA,cAAc,CAACqB,MAAf;AACD,OApCC,CAAF;AAqCAR,MAAAA,EAAE,CAAC,yEAAD,EAA4E,kBAAkB;AAC9Fb,QAAAA,cAAc,CAACc,OAAf,CAAuB,eAAvB,EACGC,IADH,GACUY,QADV,CACmB,IADnB,EACyBe,SADzB,EACoCzB,iBADpC,EAEGC,OAFH,CAEW,CAAC5B,UAAD,EAAaqD,kBAAb,CAFX;AAGA,cAAM9C,MAAM,CAACuB,aAAP,CAAqBsB,SAArB,EAAgCA,SAAhC,EAA2CzB,iBAA3C,CAAN;AACAjB,QAAAA,cAAc,CAACqB,MAAf;AACD,OANC,CAAF;AAOAR,MAAAA,EAAE,CAAC,gGAAD,EAAmG,kBAAkB;AACrH,YAAI+B,OAAO,GAAG,EACZ,GAAG3B,iBADS;AAEZO,UAAAA,WAAW,EAAE,EACX,GAAGP,kBAASO,WADD;AAEX,oCAAwB;AAFb;AAFD,SAAd;AAOAxB,QAAAA,cAAc,CAACc,OAAf,CAAuB,eAAvB,EACGC,IADH,GACUY,QADV,CACmB,IADnB,EACyBe,SADzB,EACoC;AAChClB,UAAAA,WAAW,EAAE,EACX,GAAGoB,OAAO,CAACpB,WADA;AAEX,oCAAwB;AAFb,WADmB;AAKhCqB,UAAAA,UAAU,EAAE,CAAC,EAAD;AALoB,SADpC,EAQG3B,OARH,CAQW,CAAC5B,UAAD,EAAa,iCAAqBqD,kBAArB,CAAb,CARX;AAUA,cAAM9C,MAAM,CAACuB,aAAP,CAAqBsB,SAArB,EAAgCA,SAAhC,EAA2CE,OAA3C,CAAN;AACA5C,QAAAA,cAAc,CAACqB,MAAf;AACD,OApBC,CAAF;AAqBAR,MAAAA,EAAE,CAAC,6FAAD,EAAgG,kBAAkB;AAClH,cAAM+B,OAAO,GAAG,EACd,GAAG3B,iBADW;AAEdO,UAAAA,WAAW,EAAE;AACX,oCAAwB;AADb;AAFC,SAAhB;AAOA,cAAMsB,UAAU,GAAG,EACjB,GAAGH,kBADc;AAEjBI,UAAAA,cAAc,EAAE,MAFC;AAGjBC,UAAAA,cAAc,EAAE;AAHC,SAAnB;AAMAhD,QAAAA,cAAc,CAACc,OAAf,CAAuB,eAAvB,EAAwCmC,KAAxC;AACA,cAAMpD,MAAM,CAACuB,aAAP,CAAqB0B,UAArB,EAAiCJ,SAAjC,EAA4CE,OAA5C,CAAN;AACA5C,QAAAA,cAAc,CAACqB,MAAf;AACD,OAjBC,CAAF;AAmBAR,MAAAA,EAAE,CAAC,0CAAD,EAA6C,kBAAkB;AAC/D,cAAMqC,UAAN,SAAyBC,sBAAzB,CAAoC;;AAEpC,cAAM1B,IAAI,GAAG;AAAClB,UAAAA,MAAM,EAAE;AAAC6C,YAAAA,IAAI,EAAE;AAACC,cAAAA,SAAS,EAAE;AAAZ;AAAP;AAAT,SAAb;AACA,SAACxD,MAAD,EAASG,cAAT,IAA2BP,sBAAsB,CAACgC,IAAD,EAAOyB,UAAP,CAAjD;AACA,cAAM;AAACI,UAAAA;AAAD,YAAU,MAAMzD,MAAM,CAACuB,aAAP,CAAqBsB,SAArB,EAAgCA,SAAhC,EAA2CzB,iBAA3C,CAAtB;;AACA,YAAI;AACFjB,UAAAA,cAAc,CAACG,WAAf,CAA2BoD,OAA3B,CAAmCjB,MAAnC,CAA0CkB,GAA1C,CAA8C;AAACH,YAAAA,SAAS,EAAE;AAAZ,WAA9C;AACD,SAFD,SAEU;AACR,gBAAMxD,MAAM,CAACe,aAAP,CAAqB0C,KAAK,CAAC,CAAD,CAA1B,CAAN;AACD;AACF,OAXC,CAAF;AAYD,KAvIO,CAAR;AAwIA/D,IAAAA,QAAQ,CAAC,eAAD,EAAkB,YAAY;AACpC,UAAIM,MAAJ;AACA,UAAIG,cAAJ;AACAR,MAAAA,UAAU,CAAC,YAAY;AACrB,SAACK,MAAD,EAASG,cAAT,IAA2BP,sBAAsB,EAAjD;AACD,OAFS,CAAV;AAGAiB,MAAAA,SAAS,CAAC,YAAY;AACpBV,QAAAA,cAAc,CAACW,OAAf;AACD,OAFQ,CAAT;AAGAE,MAAAA,EAAE,CAAC,0CAAD,EAA6C,kBAAkB;AAC/D,YAAI,CAAC4C,SAAD,IAAc,CAAC,MAAM5D,MAAM,CAACuB,aAAP,CAAqB,IAArB,EAA2B,IAA3B,EAAiCH,iBAAjC,CAAP,EAAmDqC,KAArE;AACA,YAAIlB,QAAQ,GAAG,MAAMvC,MAAM,CAACwC,WAAP,EAArB;AACAD,QAAAA,QAAQ,CAACE,MAAT,CAAgBC,IAAhB,CAAqBC,MAArB,CAA4B,CAA5B;AACA,cAAM3C,MAAM,CAACe,aAAP,CAAqB6C,SAArB,CAAN;AACArB,QAAAA,QAAQ,GAAG,MAAMvC,MAAM,CAACwC,WAAP,EAAjB;AACAD,QAAAA,QAAQ,CAACE,MAAT,CAAgBC,IAAhB,CAAqBC,MAArB,CAA4B,CAA5B;AACD,OAPC,CAAF;AAQA3B,MAAAA,EAAE,CAAC,kDAAD,EAAqD,kBAAkB;AACvE,cAAM,CAAC4C,SAAD,IAAc,CAAC,MAAM5D,MAAM,CAACuB,aAAP,CAAqB,IAArB,EAA2B,IAA3B,EAAiCH,iBAAjC,CAAP,EAAmDqC,KAAvE;AACAtD,QAAAA,cAAc,CAACc,OAAf,CAAuB,eAAvB,EACGC,IADH,GACUC,aADV,CACwByC,SADxB,EACmC,EADnC,EAEGvC,OAFH;AAGA,cAAMrB,MAAM,CAACe,aAAP,CAAqB6C,SAArB,CAAN;AACAzD,QAAAA,cAAc,CAACqB,MAAf;AAGA,cAAMrB,cAAc,CAAC0D,MAAf,CAAsB9C,aAAtB,EAAN;AACD,OAVC,CAAF;AAWD,KA5BO,CAAR;AA6BArB,IAAAA,QAAQ,CAAC,aAAD,EAAgB,YAAY;AAClC,UAAIM,MAAJ,EAAYG,cAAZ;AACA,UAAIoC,QAAJ;AACAuB,MAAAA,MAAM,CAAC,YAAY;AACjB,SAAC9D,MAAD,EAASG,cAAT,IAA2BP,sBAAsB,EAAjD;AACD,OAFK,CAAN;AAGAiB,MAAAA,SAAS,CAAC,kBAAkB;AAC1B,aAAK,IAAIkD,OAAT,IAAoBxB,QAApB,EAA8B;AAC5B,gBAAMvC,MAAM,CAACe,aAAP,CAAqBgD,OAAO,CAACC,EAA7B,CAAN;AACD;;AACD7D,QAAAA,cAAc,CAACW,OAAf;AACD,OALQ,CAAT;AAMAE,MAAAA,EAAE,CAAC,0CAAD,EAA6C,kBAAkB;AAC/DuB,QAAAA,QAAQ,GAAG,MAAMvC,MAAM,CAACwC,WAAP,EAAjB;AACAD,QAAAA,QAAQ,CAACE,MAAT,CAAgBwB,EAAhB,CAAmBC,EAAnB,CAAsB,OAAtB;AACA3B,QAAAA,QAAQ,CAACE,MAAT,CAAgBwB,EAAhB,CAAmBE,KAAnB;AACD,OAJC,CAAF;AAKAnD,MAAAA,EAAE,CAAC,gCAAD,EAAmC,kBAAkB;AACrD,YAAIoD,KAAK,GAAG;AAACzC,UAAAA,WAAW,EAAE,EAAC,GAAGL,0BAAJ;AAAuB,0BAAc;AAArC;AAAd,SAAZ;AACA,YAAI+C,KAAK,GAAG;AAAC1C,UAAAA,WAAW,EAAE,EAAC,GAAGL,0BAAJ;AAAuB,0BAAc;AAArC;AAAd,SAAZ;AACAnB,QAAAA,cAAc,CAACc,OAAf,CAAuB,eAAvB,EAAwCC,IAAxC,GACGG,OADH,CACW,CAAC,mBAAD,EAAsB,iCAAqB+C,KAAK,CAACzC,WAA3B,CAAtB,CADX;AAEA,YAAI,CAAC2C,UAAD,EAAaC,YAAb,IAA6B,CAAC,MAAMvE,MAAM,CAACuB,aAAP,CAAqB,IAArB,EAA2B,IAA3B,EAAiC6C,KAAjC,CAAP,EAAgDX,KAAjF;AACAtD,QAAAA,cAAc,CAACc,OAAf,CAAuB,eAAvB,EAAwCC,IAAxC,GACGG,OADH,CACW,CAAC,mBAAD,EAAsB,iCAAqBgD,KAAK,CAAC1C,WAA3B,CAAtB,CADX;AAEA,YAAI,CAAC6C,UAAD,EAAaC,YAAb,IAA6B,CAAC,MAAMzE,MAAM,CAACuB,aAAP,CAAqB,IAArB,EAA2B,IAA3B,EAAiC8C,KAAjC,CAAP,EAAgDZ,KAAjF;AAEAlB,QAAAA,QAAQ,GAAG,MAAMvC,MAAM,CAACwC,WAAP,EAAjB;AACAD,QAAAA,QAAQ,CAACE,MAAT,CAAgBwB,EAAhB,CAAmBC,EAAnB,CAAsB,OAAtB;AACA3B,QAAAA,QAAQ,CAACE,MAAT,CAAgBC,IAAhB,CAAqBC,MAArB,CAA4B,CAA5B;AACAJ,QAAAA,QAAQ,CAAC,CAAD,CAAR,CAAYyB,EAAZ,CAAevB,MAAf,CAAsBiC,KAAtB,CAA4BJ,UAA5B;AACA,yCAAqBF,KAAK,CAACzC,WAA3B,EAAwCc,MAAxC,CAA+CkB,GAA/C,CAAmDY,YAAnD;AACAhC,QAAAA,QAAQ,CAAC,CAAD,CAAR,CAAYyB,EAAZ,CAAevB,MAAf,CAAsBiC,KAAtB,CAA4BF,UAA5B;AACA,yCAAqBH,KAAK,CAAC1C,WAA3B,EAAwCc,MAAxC,CAA+CkB,GAA/C,CAAmDc,YAAnD;AACD,OAjBC,CAAF;AAkBD,KAnCO,CAAR;AAoCA/E,IAAAA,QAAQ,CAAC,WAAD,EAAc,YAAY;AAChC,UAAIM,MAAJ;AACA8D,MAAAA,MAAM,CAAC,YAAY;AACjB9D,QAAAA,MAAM,GAAG,IAAIC,oBAAJ,CAAiB,EAAjB,CAAT;AACD,OAFK,CAAN;AAGAe,MAAAA,EAAE,CAAC,wBAAD,EAA2B,kBAAkB;AAC7C,YAAI2D,MAAM,GAAG,MAAM3E,MAAM,CAAC4E,SAAP,EAAnB;AACAD,QAAAA,MAAM,CAACE,KAAP,CAAapC,MAAb,CAAoBqC,KAApB;AACAH,QAAAA,MAAM,CAACE,KAAP,CAAalE,OAAb,CAAqB8B,MAArB,CAA4BqC,KAA5B;AACD,OAJC,CAAF;AAKD,KAVO,CAAR;AAWApF,IAAAA,QAAQ,CAAC,eAAD,EAAkB,YAAY,CACrC,CADO,CAAR;AAEAA,IAAAA,QAAQ,CAAC,iCAAD,EAAoC,YAAY;AACtD,UAAIM,MAAJ;AACA,UAAIG,cAAJ;AACAR,MAAAA,UAAU,CAAC,YAAY;AACrB,SAACK,MAAD,EAASG,cAAT,IAA2BP,sBAAsB,EAAjD;AACD,OAFS,CAAV;AAGAiB,MAAAA,SAAS,CAAC,kBAAkB;AAC1B,cAAMV,cAAc,CAAC0D,MAAf,CAAsB9C,aAAtB,EAAN;AACAZ,QAAAA,cAAc,CAACW,OAAf;AACAd,QAAAA,MAAM,CAAC4B,IAAP,CAAYC,mBAAZ,GAAkC,EAAlC;AACD,OAJQ,CAAT;AAMAb,MAAAA,EAAE,CAAC,wEAAD,EAA2E,kBAAkB;AAC7F,YAAI,CAAC4C,SAAD,IAAe,CAAC,MAAM5D,MAAM,CAACuB,aAAP,CAAqB,IAArB,EAA2B,IAA3B,EAAiCY,gBAAE4C,KAAF,CAAQ3D,iBAAR,CAAjC,CAAP,EAA4DqC,KAA/E;;AACAtB,wBAAE6C,IAAF,CAAOhF,MAAM,CAACuC,QAAd,EAAwBE,MAAxB,CAA+BwC,OAA/B,CAAuCrB,SAAvC;;AACA5D,QAAAA,MAAM,CAACuC,QAAP,CAAgBqB,SAAhB,EAA2BsB,YAA3B,CAAwCC,IAAxC,CAA6C,sBAA7C,EAAqE,IAAIC,KAAJ,CAAU,MAAV,CAArE;AAEA,cAAM,qBAAM,CAAN,CAAN;;AACAjD,wBAAE6C,IAAF,CAAOhF,MAAM,CAACuC,QAAd,EAAwBE,MAAxB,CAA+B4C,GAA/B,CAAmCJ,OAAnC,CAA2CrB,SAA3C;AACD,OAPC,CAAF;AAQA5C,MAAAA,EAAE,CAAC,wEAAD,EAA2E,kBAAkB;AAC7F,YAAI,CAAC4C,SAAD,IAAe,CAAC,MAAM5D,MAAM,CAACuB,aAAP,CAAqB,IAArB,EAA2B,IAA3B,EAAiCY,gBAAE4C,KAAF,CAAQ3D,iBAAR,CAAjC,CAAP,EAA4DqC,KAA/E;;AACAtB,wBAAE6C,IAAF,CAAOhF,MAAM,CAACuC,QAAd,EAAwBE,MAAxB,CAA+BwC,OAA/B,CAAuCrB,SAAvC;;AACA5D,QAAAA,MAAM,CAACuC,QAAP,CAAgBqB,SAAhB,EAA2BsB,YAA3B,CAAwCC,IAAxC,CAA6C,sBAA7C;AAEA,cAAM,qBAAM,CAAN,CAAN;;AACAhD,wBAAE6C,IAAF,CAAOhF,MAAM,CAACuC,QAAd,EAAwBE,MAAxB,CAA+B4C,GAA/B,CAAmCJ,OAAnC,CAA2CrB,SAA3C;AACD,OAPC,CAAF;AAQD,KA5BO,CAAR;AA6BAlE,IAAAA,QAAQ,CAAC,uBAAD,EAA0B,YAAY;AAC5C,YAAM4F,YAAN,CAAmB;;AACnBA,MAAAA,YAAY,CAACC,UAAb,GAA0B,QAA1B;;AAEA,YAAMC,UAAN,CAAiB;;AACjBA,MAAAA,UAAU,CAACD,UAAX,GAAwB,MAAxB;;AAEA,YAAME,cAAN,CAAqB;;AACrBA,MAAAA,cAAc,CAACF,UAAf,GAA4B,UAA5B;AAEA5F,MAAAA,UAAU,CAAC,YAAY;AACrB;AAIA,oCAAe,QAAf,EAAyB6F,UAAU,CAACD,UAApC,EAAgD;AAC9CG,UAAAA,IAAI,EAAE,QADwC;AAE9CC,UAAAA,UAAU,EAAE;AACVnC,YAAAA,SAAS,EAAE;AACTkC,cAAAA,IAAI,EAAE,QADG;AAETE,cAAAA,OAAO,EAAE;AAFA;AADD;AAFkC,SAAhD;AASA,oCAAe,QAAf,EAAyBH,cAAc,CAACF,UAAxC,EAAoD;AAClDG,UAAAA,IAAI,EAAE,QAD4C;AAElDC,UAAAA,UAAU,EAAE;AACVE,YAAAA,GAAG,EAAE;AACHH,cAAAA,IAAI,EAAE,OADH;AAEHE,cAAAA,OAAO,EAAE;AAFN;AADK;AAFsC,SAApD;AASA;AACD,OAxBS,CAAV;AA0BAlG,MAAAA,QAAQ,CAAC,2BAAD,EAA8B,YAAY;AAChDsB,QAAAA,EAAE,CAAC,yBAAD,EAA4B,YAAY;AACxC,gBAAMhB,MAAM,GAAG,IAAIC,oBAAJ,CAAiB,EAAjB,CAAf;AACAD,UAAAA,MAAM,CAAC8F,aAAP,GAAuB,CAACR,YAAD,EAAeE,UAAf,CAAvB;;AACA,eAAK,MAAMO,MAAX,IAAqB/F,MAAM,CAACgG,qBAAP,EAArB,EAAqD;AACnDvD,YAAAA,MAAM,CAAC4C,GAAP,CAAWP,KAAX,CAAiBiB,MAAM,CAACrC,OAAxB;AACD;AACF,SANC,CAAF;AAOD,OARO,CAAR;AAUAhE,MAAAA,QAAQ,CAAC,4CAAD,EAA+C,YAAY;AACjEsB,QAAAA,EAAE,CAAC,yBAAD,EAA4B,YAAY;AACxC,gBAAMhB,MAAM,GAAG,IAAIC,oBAAJ,CAAiB;AAAC8F,YAAAA,MAAM,EAAE;AAAC,eAACP,UAAU,CAACD,UAAZ,GAAyB;AAAC/B,gBAAAA,SAAS,EAAE;AAAZ;AAA1B;AAAT,WAAjB,CAAf;AACAxD,UAAAA,MAAM,CAAC8F,aAAP,GAAuB,CAACR,YAAD,EAAeE,UAAf,CAAvB;;AACA,eAAK,MAAMO,MAAX,IAAqB/F,MAAM,CAACgG,qBAAP,EAArB,EAAqD;AACnDvD,YAAAA,MAAM,CAAC4C,GAAP,CAAWP,KAAX,CAAiBiB,MAAM,CAACrC,OAAxB;AACD;AACF,SANC,CAAF;AAQAhE,QAAAA,QAAQ,CAAC,iCAAD,EAAoC,YAAY;AACtDsB,UAAAA,EAAE,CAAC,yBAAD,EAA4B,YAAY;AACxC,kBAAMhB,MAAM,GAAG,IAAIC,oBAAJ,CAAiB;AAAC8F,cAAAA,MAAM,EAAE;AAAC,iBAACN,cAAc,CAACF,UAAhB,GAA6B;AAACM,kBAAAA,GAAG,EAAE;AAAN;AAA9B;AAAT,aAAjB,CAAf;AACA7F,YAAAA,MAAM,CAAC8F,aAAP,GAAuB,CAACR,YAAD,EAAeE,UAAf,EAA2BC,cAA3B,CAAvB;;AACA,iBAAK,MAAMM,MAAX,IAAqB/F,MAAM,CAACgG,qBAAP,EAArB,EAAqD;AACnDvD,cAAAA,MAAM,CAAC4C,GAAP,CAAWP,KAAX,CAAiBiB,MAAM,CAACrC,OAAxB;AACD;AACF,WANC,CAAF;AAOD,SARO,CAAR;AASD,OAlBO,CAAR;AAoBAhE,MAAAA,QAAQ,CAAC,gDAAD,EAAmD,YAAY;AACrEsB,QAAAA,EAAE,CAAC,kCAAD,EAAqC,YAAY;AACjD,gBAAMhB,MAAM,GAAG,IAAIC,oBAAJ,CAAiB;AAAC8F,YAAAA,MAAM,EAAE;AAACnE,cAAAA,IAAI,EAAE;AAAC4B,gBAAAA,SAAS,EAAE;AAAZ;AAAP;AAAT,WAAjB,CAAf;AACAxD,UAAAA,MAAM,CAAC8F,aAAP,GAAuB,CAACN,UAAD,CAAvB;;AACA,gBAAMO,MAAM,GAAG5D,gBAAE8D,KAAF,CAAQjG,MAAM,CAACgG,qBAAP,EAAR,CAAf;;AACAD,UAAAA,MAAM,CAACrC,OAAP,CAAejB,MAAf,CAAsBkB,GAAtB,CAA0B;AAACH,YAAAA,SAAS,EAAE;AAAZ,WAA1B;AACD,SALC,CAAF;AAMD,OAPO,CAAR;AAQD,KA1EO,CAAR;AA2ED,GAjVO,CAAR;AAkVD,CAvVO,CAAR","sourcesContent":["// transpile:mocha\n\nimport { BaseDriver } from '@appium/base-driver';\nimport { FakeDriver } from '@appium/fake-driver';\nimport { sleep } from 'asyncbox';\nimport _ from 'lodash';\nimport sinon from 'sinon';\nimport { AppiumDriver } from '../lib/appium';\nimport { finalizeSchema, registerSchema, resetSchema } from '../lib/schema/schema';\nimport { insertAppiumPrefixes, removeAppiumPrefixes } from '../lib/utils';\nimport { BASE_CAPS, W3C_CAPS, W3C_PREFIXED_CAPS } from './helpers';\n\n\nconst SESSION_ID = 1;\n\ndescribe('AppiumDriver', function () {\n  beforeEach(function () {\n    resetSchema();\n    finalizeSchema();\n  });\n  describe('instance method', function () {\n    function getDriverAndFakeDriver (appiumArgs = {}, DriverClass = FakeDriver) {\n      const appium = new AppiumDriver(appiumArgs);\n      const fakeDriver = new DriverClass();\n      const mockFakeDriver = sinon.mock(fakeDriver);\n      mockFakeDriver._fakeDriver = fakeDriver;\n      const mockedDriverReturnerClass = function Driver () {\n        return fakeDriver;\n      };\n\n      appium._findMatchingDriver = function () {\n        return {\n          driver: mockedDriverReturnerClass,\n          version: '1.2.3',\n          driverName: 'fake',\n        };\n      };\n      return [appium, mockFakeDriver];\n    }\n    describe('createSession', function () {\n      let appium;\n      let mockFakeDriver;\n      beforeEach(function () {\n        [appium, mockFakeDriver] = getDriverAndFakeDriver();\n      });\n      afterEach(async function () {\n        mockFakeDriver.restore();\n        await appium.deleteSession(SESSION_ID);\n      });\n\n      it(`should call inner driver's createSession with desired capabilities`, async function () {\n        mockFakeDriver.expects('createSession')\n          .once().withExactArgs(null, null, W3C_CAPS, [])\n          .returns([SESSION_ID, removeAppiumPrefixes(W3C_PREFIXED_CAPS)]);\n        await appium.createSession(null, null, W3C_CAPS);\n        mockFakeDriver.verify();\n      });\n      it(`should call inner driver's createSession with desired and default capabilities`, async function () {\n        let defaultCaps = {'appium:someCap': 'hello'};\n        let allCaps = {...W3C_CAPS, alwaysMatch: {...W3C_CAPS.alwaysMatch, ...defaultCaps}};\n        appium.args.defaultCapabilities = defaultCaps;\n        mockFakeDriver.expects('createSession')\n          .once().withArgs(null, null, allCaps)\n          .returns([SESSION_ID, removeAppiumPrefixes(allCaps.alwaysMatch)]);\n        await appium.createSession(null, null, W3C_CAPS);\n        mockFakeDriver.verify();\n      });\n      it(`should call inner driver's createSession with desired and default capabilities without overriding caps`, async function () {\n        // a default capability with the same key as a desired capability\n        // should do nothing\n        let defaultCaps = {platformName: 'Ersatz'};\n        appium.args.defaultCapabilities = defaultCaps;\n        mockFakeDriver.expects('createSession')\n          .once().withArgs(null, null, W3C_CAPS)\n          .returns([SESSION_ID, removeAppiumPrefixes(W3C_PREFIXED_CAPS)]);\n        await appium.createSession(null, null, W3C_CAPS);\n        mockFakeDriver.verify();\n      });\n      it('should kill all other sessions if sessionOverride is on', async function () {\n        appium.args.sessionOverride = true;\n\n        // mock three sessions that should be removed when the new one is created\n        let fakeDrivers = [\n          new FakeDriver(),\n          new FakeDriver(),\n          new FakeDriver(),\n        ];\n        let mockFakeDrivers = _.map(fakeDrivers, (fd) => sinon.mock(fd));\n        mockFakeDrivers[0].expects('deleteSession')\n          .once();\n        mockFakeDrivers[1].expects('deleteSession')\n          .once()\n          .throws('Cannot shut down Android driver; it has already shut down');\n        mockFakeDrivers[2].expects('deleteSession')\n          .once();\n        appium.sessions['abc-123-xyz'] = fakeDrivers[0];\n        appium.sessions['xyz-321-abc'] = fakeDrivers[1];\n        appium.sessions['123-abc-xyz'] = fakeDrivers[2];\n\n        let sessions = await appium.getSessions();\n        sessions.should.have.length(3);\n\n        mockFakeDriver.expects('createSession')\n          .once().withExactArgs(null, null, W3C_CAPS, [])\n          .returns([SESSION_ID, removeAppiumPrefixes(W3C_PREFIXED_CAPS)]);\n        await appium.createSession(null, null, W3C_CAPS);\n\n        sessions = await appium.getSessions();\n        sessions.should.have.length(1);\n\n        for (let mfd of mockFakeDrivers) {\n          mfd.verify();\n        }\n        mockFakeDriver.verify();\n      });\n      it('should call \"createSession\" with W3C capabilities argument, if provided', async function () {\n        mockFakeDriver.expects('createSession')\n          .once().withArgs(null, undefined, W3C_CAPS)\n          .returns([SESSION_ID, BASE_CAPS]);\n        await appium.createSession(undefined, undefined, W3C_CAPS);\n        mockFakeDriver.verify();\n      });\n      it('should call \"createSession\" with W3C capabilities argument with additional provided parameters', async function () {\n        let w3cCaps = {\n          ...W3C_CAPS,\n          alwaysMatch: {\n            ...W3C_CAPS.alwaysMatch,\n            'appium:someOtherParm': 'someOtherParm',\n          },\n        };\n        mockFakeDriver.expects('createSession')\n          .once().withArgs(null, undefined, {\n            alwaysMatch: {\n              ...w3cCaps.alwaysMatch,\n              'appium:someOtherParm': 'someOtherParm',\n            },\n            firstMatch: [{}],\n          })\n          .returns([SESSION_ID, insertAppiumPrefixes(BASE_CAPS)]);\n\n        await appium.createSession(undefined, undefined, w3cCaps);\n        mockFakeDriver.verify();\n      });\n      it('should not call \"createSession\" with JSONWP capabilities if W3C has incomplete capabilities', async function () {\n        const w3cCaps = {\n          ...W3C_CAPS,\n          alwaysMatch: {\n            'appium:someOtherParm': 'someOtherParm',\n          },\n        };\n\n        const jsonwpCaps = {\n          ...BASE_CAPS,\n          automationName: 'Fake',\n          someOtherParam: 'someOtherParam',\n        };\n\n        mockFakeDriver.expects('createSession').never();\n        await appium.createSession(jsonwpCaps, undefined, w3cCaps);\n        mockFakeDriver.verify();\n      });\n\n      it('should assign args to property `cliArgs`', async function () {\n        class ArgsDriver extends BaseDriver {\n        }\n        const args = {driver: {fake: {randomArg: 1234}}};\n        [appium, mockFakeDriver] = getDriverAndFakeDriver(args, ArgsDriver);\n        const {value} = await appium.createSession(undefined, undefined, W3C_CAPS);\n        try {\n          mockFakeDriver._fakeDriver.cliArgs.should.eql({randomArg: 1234});\n        } finally {\n          await appium.deleteSession(value[0]);\n        }\n      });\n    });\n    describe('deleteSession', function () {\n      let appium;\n      let mockFakeDriver;\n      beforeEach(function () {\n        [appium, mockFakeDriver] = getDriverAndFakeDriver();\n      });\n      afterEach(function () {\n        mockFakeDriver.restore();\n      });\n      it('should remove the session if it is found', async function () {\n        let [sessionId] = (await appium.createSession(null, null, W3C_CAPS)).value;\n        let sessions = await appium.getSessions();\n        sessions.should.have.length(1);\n        await appium.deleteSession(sessionId);\n        sessions = await appium.getSessions();\n        sessions.should.have.length(0);\n      });\n      it('should call inner driver\\'s deleteSession method', async function () {\n        const [sessionId] = (await appium.createSession(null, null, W3C_CAPS)).value;\n        mockFakeDriver.expects('deleteSession')\n          .once().withExactArgs(sessionId, [])\n          .returns();\n        await appium.deleteSession(sessionId);\n        mockFakeDriver.verify();\n\n        // cleanup, since we faked the delete session call\n        await mockFakeDriver.object.deleteSession();\n      });\n    });\n    describe('getSessions', function () {\n      let appium, mockFakeDriver;\n      let sessions;\n      before(function () {\n        [appium, mockFakeDriver] = getDriverAndFakeDriver();\n      });\n      afterEach(async function () {\n        for (let session of sessions) {\n          await appium.deleteSession(session.id);\n        }\n        mockFakeDriver.restore();\n      });\n      it('should return an empty array of sessions', async function () {\n        sessions = await appium.getSessions();\n        sessions.should.be.an('array');\n        sessions.should.be.empty;\n      });\n      it('should return sessions created', async function () {\n        let caps1 = {alwaysMatch: {...W3C_PREFIXED_CAPS, 'appium:cap': 'value'}};\n        let caps2 = {alwaysMatch: {...W3C_PREFIXED_CAPS, 'appium:cap': 'other value'}};\n        mockFakeDriver.expects('createSession').once()\n          .returns(['fake-session-id-1', removeAppiumPrefixes(caps1.alwaysMatch)]);\n        let [session1Id, session1Caps] = (await appium.createSession(null, null, caps1)).value;\n        mockFakeDriver.expects('createSession').once()\n          .returns(['fake-session-id-2', removeAppiumPrefixes(caps2.alwaysMatch)]);\n        let [session2Id, session2Caps] = (await appium.createSession(null, null, caps2)).value;\n\n        sessions = await appium.getSessions();\n        sessions.should.be.an('array');\n        sessions.should.have.length(2);\n        sessions[0].id.should.equal(session1Id);\n        removeAppiumPrefixes(caps1.alwaysMatch).should.eql(session1Caps);\n        sessions[1].id.should.equal(session2Id);\n        removeAppiumPrefixes(caps2.alwaysMatch).should.eql(session2Caps);\n      });\n    });\n    describe('getStatus', function () {\n      let appium;\n      before(function () {\n        appium = new AppiumDriver({});\n      });\n      it('should return a status', async function () {\n        let status = await appium.getStatus();\n        status.build.should.exist;\n        status.build.version.should.exist;\n      });\n    });\n    describe('sessionExists', function () {\n    });\n    describe('attachUnexpectedShutdownHandler', function () {\n      let appium;\n      let mockFakeDriver;\n      beforeEach(function () {\n        [appium, mockFakeDriver] = getDriverAndFakeDriver();\n      });\n      afterEach(async function () {\n        await mockFakeDriver.object.deleteSession();\n        mockFakeDriver.restore();\n        appium.args.defaultCapabilities = {};\n      });\n\n      it('should remove session if inner driver unexpectedly exits with an error', async function () {\n        let [sessionId,] = (await appium.createSession(null, null, _.clone(W3C_CAPS))).value; // eslint-disable-line comma-spacing\n        _.keys(appium.sessions).should.contain(sessionId);\n        appium.sessions[sessionId].eventEmitter.emit('onUnexpectedShutdown', new Error('Oops'));\n        // let event loop spin so rejection is handled\n        await sleep(1);\n        _.keys(appium.sessions).should.not.contain(sessionId);\n      });\n      it('should remove session if inner driver unexpectedly exits with no error', async function () {\n        let [sessionId,] = (await appium.createSession(null, null, _.clone(W3C_CAPS))).value; // eslint-disable-line comma-spacing\n        _.keys(appium.sessions).should.contain(sessionId);\n        appium.sessions[sessionId].eventEmitter.emit('onUnexpectedShutdown');\n        // let event loop spin so rejection is handled\n        await sleep(1);\n        _.keys(appium.sessions).should.not.contain(sessionId);\n      });\n    });\n    describe('createPluginInstances', function () {\n      class NoArgsPlugin {}\n      NoArgsPlugin.pluginName = 'noargs';\n\n      class ArgsPlugin {}\n      ArgsPlugin.pluginName = 'args';\n\n      class ArrayArgPlugin {}\n      ArrayArgPlugin.pluginName = 'arrayarg';\n\n      beforeEach(function () {\n        resetSchema();\n        // to establish defaults, we need to register a schema for the plugin.\n        // note that the `noargs` plugin does not need a schema, because it\n        // accepts no arguments.\n        registerSchema('plugin', ArgsPlugin.pluginName, {\n          type: 'object',\n          properties: {\n            randomArg: {\n              type: 'number',\n              default: 2000\n            }\n          }\n        });\n        registerSchema('plugin', ArrayArgPlugin.pluginName, {\n          type: 'object',\n          properties: {\n            arr: {\n              type: 'array',\n              default: []\n            }\n          }\n        });\n        finalizeSchema();\n      });\n\n      describe('when args are not present', function () {\n        it('should not set CLI args', function () {\n          const appium = new AppiumDriver({});\n          appium.pluginClasses = [NoArgsPlugin, ArgsPlugin];\n          for (const plugin of appium.createPluginInstances()) {\n            should.not.exist(plugin.cliArgs);\n          }\n        });\n      });\n\n      describe('when args are equal to the schema defaults', function () {\n        it('should not set CLI args', function () {\n          const appium = new AppiumDriver({plugin: {[ArgsPlugin.pluginName]: {randomArg: 2000}}});\n          appium.pluginClasses = [NoArgsPlugin, ArgsPlugin];\n          for (const plugin of appium.createPluginInstances()) {\n            should.not.exist(plugin.cliArgs);\n          }\n        });\n\n        describe('when the default is an \"object\"', function () {\n          it('should not set CLI args', function () {\n            const appium = new AppiumDriver({plugin: {[ArrayArgPlugin.pluginName]: {arr: []}}});\n            appium.pluginClasses = [NoArgsPlugin, ArgsPlugin, ArrayArgPlugin];\n            for (const plugin of appium.createPluginInstances()) {\n              should.not.exist(plugin.cliArgs);\n            }\n          });\n        });\n      });\n\n      describe('when args are not equal to the schema defaults', function () {\n        it('should add cliArgs to the plugin', function () {\n          const appium = new AppiumDriver({plugin: {args: {randomArg: 1234}}});\n          appium.pluginClasses = [ArgsPlugin];\n          const plugin = _.first(appium.createPluginInstances());\n          plugin.cliArgs.should.eql({randomArg: 1234});\n        });\n      });\n    });\n  });\n});\n"],"file":"test/driver-specs.js","sourceRoot":"../.."}