appium 2.0.0-beta.2 → 2.0.0-beta.23

package/build/test/driver-specs.js

@@ -0,0 +1,321 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _appium = require("../lib/appium");
+
+var _baseDriver = require("@appium/base-driver");
+
+var _fakeDriver = require("@appium/fake-driver");
+
+var _helpers = require("./helpers");
+
+var _schema = require("../lib/schema/schema");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+var _asyncbox = require("asyncbox");
+
+var _utils = require("../lib/utils");
+
+const SESSION_ID = 1;
+describe('AppiumDriver', function () {
+  beforeEach(function () {
+    (0, _schema.resetSchema)();
+  });
+  describe('AppiumDriver', 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';
+    it('should not set CLI args if none are sent', function () {
+      const appium = new _appium.AppiumDriver({});
+      appium.pluginClasses = [NoArgsPlugin, ArgsPlugin];
+
+      for (const plugin of appium.createPluginInstances()) {
+        should.not.exist(plugin.cliArgs);
+      }
+    });
+    it('should add cliArgs to the plugin once validated', function () {
+      const appium = new _appium.AppiumDriver({
+        plugin: {
+          args: {
+            randomArg: 1234
+          }
+        }
+      });
+      appium.pluginClasses = [ArgsPlugin];
+      const plugin = appium.createPluginInstances()[0];
+      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","pluginClasses","plugin","createPluginInstances"],"mappings":"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","sourcesContent":["// transpile:mocha\n\nimport { AppiumDriver } from '../lib/appium';\nimport { BaseDriver } from '@appium/base-driver';\nimport { FakeDriver } from '@appium/fake-driver';\nimport { BASE_CAPS, W3C_CAPS, W3C_PREFIXED_CAPS } from './helpers';\nimport {resetSchema} from '../lib/schema/schema';\nimport _ from 'lodash';\nimport sinon from 'sinon';\nimport { sleep } from 'asyncbox';\nimport { insertAppiumPrefixes, removeAppiumPrefixes } from '../lib/utils';\n\n\nconst SESSION_ID = 1;\n\ndescribe('AppiumDriver', function () {\n  beforeEach(function () {\n    resetSchema();\n  });\n  describe('AppiumDriver', 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  });\n  describe('#createPluginInstances', function () {\n    class NoArgsPlugin {}\n    NoArgsPlugin.pluginName = 'noargs';\n\n    class ArgsPlugin {}\n    ArgsPlugin.pluginName = 'args';\n\n    it('should not set CLI args if none are sent', 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    it('should add cliArgs to the plugin once validated', function () {\n      const appium = new AppiumDriver({plugin: {args: {randomArg: 1234}}});\n      appium.pluginClasses = [ArgsPlugin];\n      const plugin = appium.createPluginInstances()[0];\n      plugin.cliArgs.should.eql({randomArg: 1234});\n    });\n  });\n});\n"],"file":"test/driver-specs.js","sourceRoot":"../.."}

package/build/test/ext-config-io-specs.js

@@ -0,0 +1,181 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _fs = require("fs");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+var _yaml = _interopRequireDefault(require("yaml"));
+
+var _helpers = require("./helpers");
+
+const expect = chai.expect;
+describe('ExtensionConfigIO', function () {
+  let sandbox;
+  let yamlFixture;
+  before(async function () {
+    yamlFixture = await _fs.promises.readFile(_path.default.join(__dirname, 'fixtures', 'extensions.yaml'), 'utf8');
+  });
+  let getExtConfigIOInstance;
+  let mocks;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    mocks = {
+      '@appium/support': {
+        fs: {
+          readFile: sandbox.stub().resolves(yamlFixture),
+          writeFile: sandbox.stub().resolves(true)
+        },
+        mkdirp: sandbox.stub().resolves()
+      }
+    };
+    getExtConfigIOInstance = _helpers.rewiremock.proxy('../lib/ext-config-io', mocks).getExtConfigIOInstance;
+  });
+  afterEach(function () {
+    sandbox.restore();
+    getExtConfigIOInstance.cache = new Map();
+  });
+  describe('instantiation', function () {
+    describe('when called twice with the same `appiumHome` value', function () {
+      it('should return the same object both times', function () {
+        const firstInstance = getExtConfigIOInstance('/some/path');
+        const secondInstance = getExtConfigIOInstance('/some/path');
+        expect(firstInstance).to.equal(secondInstance);
+      });
+    });
+    describe('when called twice with different `appiumHome` values', function () {
+      it('should return different objects', function () {
+        const firstInstance = getExtConfigIOInstance('/some/path');
+        const secondInstance = getExtConfigIOInstance('/some/other/path');
+        expect(firstInstance).to.not.equal(secondInstance);
+      });
+    });
+  });
+  describe('property', function () {
+    describe('filepath', function () {
+      it('should not be writable', function () {
+        const instance = getExtConfigIOInstance('/some/path');
+        expect(() => {
+          instance.filepath = '/some/other/path';
+        }).to.throw(TypeError);
+      });
+    });
+  });
+  describe('read()', function () {
+    let io;
+    beforeEach(function () {
+      io = getExtConfigIOInstance('/some/path');
+    });
+    describe('when called with a valid extension type', function () {
+      describe('when the file does not yet exist', function () {
+        beforeEach(async function () {
+          const err = new Error();
+          err.code = 'ENOENT';
+          mocks['@appium/support'].fs.readFile.rejects(err);
+          await io.read('driver');
+        });
+        it('should create a new file', function () {
+          expect(mocks['@appium/support'].fs.writeFile).to.be.calledOnceWith(io.filepath, _yaml.default.stringify({
+            drivers: {},
+            plugins: {},
+            schemaRev: 2
+          }), 'utf8');
+        });
+      });
+      describe('when the file already exists', function () {
+        beforeEach(async function () {
+          await io.read('driver');
+        });
+        it('should attempt to create the `appiumHome` directory', function () {
+          expect(mocks['@appium/support'].mkdirp).to.have.been.calledOnceWith('/some/path');
+        });
+        it('should attempt to read the file at `filepath`', function () {
+          expect(mocks['@appium/support'].fs.readFile).to.have.been.calledOnceWith(io.filepath, 'utf8');
+        });
+      });
+    });
+    describe('when called with an unknown extension type`', function () {
+      it('should reject', async function () {
+        const promise = io.read('unknown');
+        return await expect(promise).to.be.rejectedWith(TypeError, /invalid extension type/i);
+      });
+    });
+    describe('when called twice with the same `extensionType`', function () {
+      it('should return the same object both times', async function () {
+        const firstInstance = await io.read('driver');
+        const secondInstance = await io.read('driver');
+        expect(firstInstance).to.equal(secondInstance);
+      });
+    });
+  });
+  describe('write()', function () {
+    let io;
+    let driverData;
+    beforeEach(function () {
+      io = getExtConfigIOInstance('/some/path');
+    });
+    describe('when called after `read()`', function () {
+      beforeEach(async function () {
+        driverData = await io.read('driver');
+      });
+      describe('when called without modifying the data', function () {
+        it('should not write the file', async function () {
+          expect(await io.write()).to.be.false;
+        });
+      });
+      describe('when called after adding a property', function () {
+        beforeEach(function () {
+          driverData.foo = {
+            name: 'foo',
+            version: '1.0.0',
+            path: '/foo/path'
+          };
+        });
+        it('should write the file', async function () {
+          expect(await io.write()).to.be.true;
+        });
+      });
+      describe('when called after deleting a property', function () {
+        beforeEach(function () {
+          driverData.foo = {
+            name: 'foo',
+            version: '1.0.0',
+            path: '/foo/path'
+          };
+          io._dirty = false;
+          delete driverData.foo;
+        });
+        it('should write the file', async function () {
+          expect(await io.write()).to.be.true;
+        });
+      });
+      describe('when the config file could not be written', function () {
+        beforeEach(function () {
+          mocks['@appium/support'].fs.writeFile = sandbox.stub().rejects(new Error());
+          io._dirty = true;
+        });
+        it('should reject', async function () {
+          await expect(io.write()).to.be.rejectedWith(Error, /Appium could not parse or write/i);
+        });
+      });
+    });
+    describe('when called before `read()`', function () {
+      it('should return `false`', async function () {
+        expect(await io.write()).to.be.false;
+      });
+      describe('when called with `force: true`', function () {
+        it('should reject', async function () {
+          await expect(io.write(true)).to.be.rejectedWith(ReferenceError, 'No data to write. Call `read()` first');
+        });
+      });
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/ext-config-io-specs.js"],"names":["expect","chai","describe","sandbox","yamlFixture","before","fs","readFile","path","join","__dirname","getExtConfigIOInstance","mocks","beforeEach","sinon","createSandbox","stub","resolves","writeFile","mkdirp","rewiremock","proxy","afterEach","restore","cache","Map","it","firstInstance","secondInstance","to","equal","not","instance","filepath","throw","TypeError","io","err","Error","code","rejects","read","be","calledOnceWith","YAML","stringify","drivers","plugins","schemaRev","have","been","promise","rejectedWith","driverData","write","false","foo","name","version","true","_dirty","ReferenceError"],"mappings":"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","sourcesContent":["// @ts-check\n\nimport { promises as fs } from 'fs';\nimport path from 'path';\nimport sinon from 'sinon';\nimport YAML from 'yaml';\nimport { rewiremock } from './helpers';\nconst expect = chai.expect;\n\ndescribe('ExtensionConfigIO', function () {\n  /**\n   * @type {import('sinon').SinonSandbox}\n   */\n  let sandbox;\n\n  /** @type {string} */\n  let yamlFixture;\n\n  before(async function () {\n    yamlFixture = await fs.readFile(\n      path.join(__dirname, 'fixtures', 'extensions.yaml'),\n      'utf8',\n    );\n  });\n\n  /**\n   * @type {typeof import('../lib/ext-config-io').getExtConfigIOInstance}\n   */\n  let getExtConfigIOInstance;\n\n  let mocks;\n\n  beforeEach(function () {\n    sandbox = sinon.createSandbox();\n    mocks = {\n      '@appium/support': {\n        fs: {\n          readFile: sandbox.stub().resolves(yamlFixture),\n          writeFile: sandbox.stub().resolves(true),\n        },\n        mkdirp: sandbox.stub().resolves(),\n      },\n    };\n    getExtConfigIOInstance = rewiremock.proxy(\n      '../lib/ext-config-io',\n      mocks,\n    ).getExtConfigIOInstance;\n  });\n\n  afterEach(function () {\n    sandbox.restore();\n    getExtConfigIOInstance.cache = new Map();\n  });\n\n  describe('instantiation', function () {\n    describe('when called twice with the same `appiumHome` value', function () {\n      it('should return the same object both times', function () {\n        const firstInstance = getExtConfigIOInstance('/some/path');\n        const secondInstance = getExtConfigIOInstance('/some/path');\n        expect(firstInstance).to.equal(secondInstance);\n      });\n    });\n\n    describe('when called twice with different `appiumHome` values', function () {\n      it('should return different objects', function () {\n        const firstInstance = getExtConfigIOInstance('/some/path');\n        const secondInstance = getExtConfigIOInstance('/some/other/path');\n        expect(firstInstance).to.not.equal(secondInstance);\n      });\n    });\n  });\n\n  describe('property', function () {\n    describe('filepath', function () {\n      it('should not be writable', function () {\n        const instance = getExtConfigIOInstance('/some/path');\n        expect(() => {\n          // @ts-ignore\n          instance.filepath = '/some/other/path';\n        }).to.throw(TypeError);\n      });\n    });\n  });\n\n  describe('read()', function () {\n    /** @type {import('../lib/ext-config-io').ExtensionConfigIO} */\n    let io;\n\n    beforeEach(function () {\n      io = getExtConfigIOInstance('/some/path');\n    });\n\n    describe('when called with a valid extension type', function () {\n      describe('when the file does not yet exist', function () {\n        beforeEach(async function () {\n          /** @type {NodeJS.ErrnoException} */\n          const err = new Error();\n          err.code = 'ENOENT';\n          mocks['@appium/support'].fs.readFile.rejects(err);\n          await io.read('driver');\n        });\n\n        it('should create a new file', function () {\n          expect(mocks['@appium/support'].fs.writeFile).to.be.calledOnceWith(\n            io.filepath,\n            YAML.stringify({drivers: {}, plugins: {}, schemaRev: 2}),\n            'utf8',\n          );\n        });\n      });\n\n      describe('when the file already exists', function () {\n        beforeEach(async function () {\n          await io.read('driver');\n        });\n\n        it('should attempt to create the `appiumHome` directory', function () {\n          expect(mocks['@appium/support'].mkdirp).to.have.been.calledOnceWith(\n            '/some/path',\n          );\n        });\n\n        it('should attempt to read the file at `filepath`', function () {\n          expect(\n            mocks['@appium/support'].fs.readFile,\n          ).to.have.been.calledOnceWith(io.filepath, 'utf8');\n        });\n      });\n    });\n\n    describe('when called with an unknown extension type`', function () {\n      it('should reject', async function () {\n        // @ts-ignore\n        const promise = io.read('unknown');\n        return await expect(promise).to.be.rejectedWith(\n          TypeError,\n          /invalid extension type/i,\n        );\n      });\n    });\n\n    describe('when called twice with the same `extensionType`', function () {\n      it('should return the same object both times', async function () {\n        const firstInstance = await io.read('driver');\n        const secondInstance = await io.read('driver');\n        expect(firstInstance).to.equal(secondInstance);\n      });\n    });\n  });\n\n  describe('write()', function () {\n    let io;\n    let driverData;\n\n    beforeEach(function () {\n      io = getExtConfigIOInstance('/some/path');\n    });\n\n    describe('when called after `read()`', function () {\n      beforeEach(async function () {\n        driverData = await io.read('driver');\n      });\n\n      describe('when called without modifying the data', function () {\n        it('should not write the file', async function () {\n          expect(await io.write()).to.be.false;\n        });\n      });\n\n      describe('when called after adding a property', function () {\n        beforeEach(function () {\n          driverData.foo = {\n            name: 'foo',\n            version: '1.0.0',\n            path: '/foo/path',\n          };\n        });\n\n        it('should write the file', async function () {\n          expect(await io.write()).to.be.true;\n        });\n      });\n\n      describe('when called after deleting a property', function () {\n        beforeEach(function () {\n          driverData.foo = {\n            name: 'foo',\n            version: '1.0.0',\n            path: '/foo/path',\n          };\n          io._dirty = false;\n          delete driverData.foo;\n        });\n\n        it('should write the file', async function () {\n          expect(await io.write()).to.be.true;\n        });\n      });\n\n      describe('when the config file could not be written', function () {\n        beforeEach(function () {\n          mocks['@appium/support'].fs.writeFile = sandbox.stub().rejects(new Error());\n          io._dirty = true;\n        });\n\n        it('should reject', async function () {\n          await expect(io.write()).to.be.rejectedWith(Error, /Appium could not parse or write/i);\n        });\n      });\n\n    });\n\n    describe('when called before `read()`', function () {\n      it('should return `false`', async function () {\n        expect(await io.write()).to.be.false;\n      });\n\n      describe('when called with `force: true`', function () {\n        it('should reject', async function () {\n          await expect(io.write(true)).to.be.rejectedWith(ReferenceError, 'No data to write. Call `read()` first');\n        });\n      });\n    });\n  });\n});\n"],"file":"test/ext-config-io-specs.js","sourceRoot":"../.."}