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

package/build/test/driver-e2e-specs.js

@@ -0,0 +1,435 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+var _axios = _interopRequireDefault(require("axios"));
+
+var _webdriverio = require("webdriverio");
+
+var _main = require("../lib/main");
+
+var _extensionConfig = require("../lib/extension-config");
+
+var _helpers = require("./helpers");
+
+var _baseDriver = require("@appium/base-driver");
+
+var _driverConfig = _interopRequireDefault(require("../lib/driver-config"));
+
+var _extension = require("../lib/cli/extension");
+
+var _utils = require("../lib/utils");
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+let TEST_SERVER;
+let TEST_PORT;
+const sillyWebServerPort = 1234;
+const sillyWebServerHost = 'hey';
+const FAKE_ARGS = {
+  sillyWebServerPort,
+  sillyWebServerHost
+};
+const FAKE_DRIVER_ARGS = {
+  driver: {
+    fake: FAKE_ARGS
+  }
+};
+const shouldStartServer = process.env.USE_RUNNING_SERVER !== '0';
+const caps = _helpers.W3C_PREFIXED_CAPS;
+const wdOpts = {
+  hostname: _helpers.TEST_HOST,
+  port: null,
+  connectionRetryCount: 0
+};
+describe('FakeDriver - via HTTP', function () {
+  let server = null;
+  const appiumHome = _extensionConfig.DEFAULT_APPIUM_HOME;
+  let FakeDriver = null;
+  let baseUrl;
+
+  const FAKE_DRIVER_DIR = _path.default.join(_helpers.PROJECT_ROOT, 'packages', 'fake-driver');
+
+  before(async function () {
+    wdOpts.port = TEST_PORT = await (0, _helpers.getTestPort)();
+    TEST_SERVER = `http://${_helpers.TEST_HOST}:${TEST_PORT}`;
+    baseUrl = `${TEST_SERVER}/session`;
+    const driverList = await (0, _extension.runExtensionCommand)({
+      appiumHome,
+      driverCommand: 'list',
+      showInstalled: true
+    }, _extensionConfig.DRIVER_TYPE);
+
+    if (!_lodash.default.has(driverList, 'fake')) {
+      await (0, _extension.runExtensionCommand)({
+        appiumHome,
+        driverCommand: 'install',
+        driver: FAKE_DRIVER_DIR,
+        installType: _extensionConfig.INSTALL_TYPE_LOCAL
+      }, _extensionConfig.DRIVER_TYPE);
+    }
+
+    const config = _driverConfig.default.getInstance(appiumHome);
+
+    FakeDriver = config.require('fake');
+    await serverStart();
+  });
+  after(async function () {
+    await serverClose();
+  });
+
+  async function serverStart(args = {}) {
+    args = {
+      port: TEST_PORT,
+      host: _helpers.TEST_HOST,
+      appiumHome,
+      ...args
+    };
+
+    if (shouldStartServer) {
+      server = await (0, _main.main)(args);
+    }
+  }
+
+  async function serverClose() {
+    if (server) {
+      await server.close();
+    }
+  }
+
+  describe('server updating', function () {
+    it('should allow drivers to update the server in arbitrary ways', async function () {
+      const {
+        data
+      } = await _axios.default.get(`${TEST_SERVER}/fakedriver`);
+      data.should.eql({
+        fakedriver: 'fakeResponse'
+      });
+    });
+  });
+  describe('cli args handling for empty args', function () {
+    it('should not recieve user cli args if none passed in', async function () {
+      let driver = await (0, _webdriverio.remote)({ ...wdOpts,
+        capabilities: caps
+      });
+      const {
+        sessionId
+      } = driver;
+
+      try {
+        const {
+          data
+        } = await _axios.default.get(`${baseUrl}/${sessionId}/fakedriverargs`);
+        should.not.exist(data.value.sillyWebServerPort);
+        should.not.exist(data.value.sillyWebServerHost);
+      } finally {
+        await driver.deleteSession();
+      }
+    });
+  });
+  describe('cli args handling for passed in args', function () {
+    before(async function () {
+      await serverClose();
+      await serverStart(FAKE_DRIVER_ARGS);
+    });
+    after(async function () {
+      await serverClose();
+      await serverStart();
+    });
+    it('should receive user cli args from a driver if arguments were passed in', async function () {
+      let driver = await (0, _webdriverio.remote)({ ...wdOpts,
+        capabilities: caps
+      });
+      const {
+        sessionId
+      } = driver;
+
+      try {
+        const {
+          data
+        } = await _axios.default.get(`${baseUrl}/${sessionId}/fakedriverargs`);
+        data.value.sillyWebServerPort.should.eql(sillyWebServerPort);
+        data.value.sillyWebServerHost.should.eql(sillyWebServerHost);
+      } finally {
+        await driver.deleteSession();
+      }
+    });
+  });
+  describe('session handling', function () {
+    it('should start and stop a session and not allow commands after session stopped', async function () {
+      let driver = await (0, _webdriverio.remote)({ ...wdOpts,
+        capabilities: caps
+      });
+      should.exist(driver.sessionId);
+      driver.sessionId.should.be.a('string');
+      await driver.deleteSession();
+      await driver.getTitle().should.eventually.be.rejectedWith(/terminated/);
+    });
+    it('should be able to run two FakeDriver sessions simultaneously', async function () {
+      let driver1 = await (0, _webdriverio.remote)({ ...wdOpts,
+        capabilities: caps
+      });
+      should.exist(driver1.sessionId);
+      driver1.sessionId.should.be.a('string');
+      let driver2 = await (0, _webdriverio.remote)({ ...wdOpts,
+        capabilities: caps
+      });
+      should.exist(driver2.sessionId);
+      driver2.sessionId.should.be.a('string');
+      driver2.sessionId.should.not.equal(driver1.sessionId);
+      await driver1.deleteSession();
+      await driver2.deleteSession();
+    });
+    it('should not be able to run two FakeDriver sessions simultaneously when one is unique', async function () {
+      let uniqueCaps = _lodash.default.clone(caps);
+
+      uniqueCaps['appium:uniqueApp'] = true;
+      let driver1 = await (0, _webdriverio.remote)({ ...wdOpts,
+        capabilities: uniqueCaps
+      });
+      should.exist(driver1.sessionId);
+      driver1.sessionId.should.be.a('string');
+      await (0, _webdriverio.remote)({ ...wdOpts,
+        capabilities: caps
+      }).should.eventually.be.rejected;
+      await driver1.deleteSession();
+    });
+    it('should use the newCommandTimeout of the inner Driver on session creation', async function () {
+      let localCaps = Object.assign({
+        'appium:newCommandTimeout': 0.25
+      }, caps);
+      let driver = await (0, _webdriverio.remote)({ ...wdOpts,
+        capabilities: localCaps
+      });
+      should.exist(driver.sessionId);
+      await _bluebird.default.delay(250);
+      await driver.getPageSource().should.eventually.be.rejectedWith(/terminated/);
+    });
+    it('should accept valid W3C capabilities and start a W3C session', async function () {
+      const w3cCaps = {
+        capabilities: {
+          alwaysMatch: {
+            'appium:automationName': 'Fake',
+            platformName: 'Fake'
+          },
+          firstMatch: [{
+            'appium:deviceName': 'Fake',
+            'appium:app': _helpers.TEST_FAKE_APP
+          }]
+        }
+      };
+      const {
+        status,
+        value,
+        sessionId
+      } = (await _axios.default.post(baseUrl, w3cCaps)).data;
+
+      try {
+        should.not.exist(status);
+        should.not.exist(sessionId);
+        value.sessionId.should.be.a.string;
+        value.should.exist;
+        value.capabilities.should.deep.equal({
+          automationName: 'Fake',
+          platformName: 'Fake',
+          deviceName: 'Fake',
+          app: _helpers.TEST_FAKE_APP
+        });
+        const {
+          status: screenshotStatus,
+          value: screenshotValue
+        } = (await (0, _axios.default)({
+          url: `${baseUrl}/${value.sessionId}/screenshot`
+        })).data;
+        should.not.exist(screenshotStatus);
+        screenshotValue.should.match(/^iVBOR/);
+        await _axios.default.post(`${baseUrl}/${value.sessionId}/execute/async`, {
+          script: '',
+          args: ['a']
+        }).should.eventually.be.rejectedWith(/405/);
+      } finally {
+        await _axios.default.delete(`${baseUrl}/${value.sessionId}`);
+      }
+    });
+    it('should reject invalid W3C capabilities and respond with a 400 Bad Parameters error', async function () {
+      const badW3Ccaps = {
+        capabilities: {
+          alwaysMatch: {},
+          firstMatch: [{
+            'appium:deviceName': 'Fake',
+            'appium:app': _helpers.TEST_FAKE_APP
+          }]
+        }
+      };
+      await _axios.default.post(baseUrl, badW3Ccaps).should.eventually.be.rejectedWith(/400/);
+    });
+    it('should accept a combo of W3C and JSONWP capabilities but completely ignore JSONWP', async function () {
+      const combinedCaps = {
+        'desiredCapabilities': { ...caps,
+          jsonwpParam: 'jsonwpParam'
+        },
+        'capabilities': {
+          'alwaysMatch': { ...caps
+          },
+          'firstMatch': [{
+            'appium:w3cParam': 'w3cParam'
+          }]
+        }
+      };
+      const {
+        status,
+        value,
+        sessionId
+      } = (await _axios.default.post(baseUrl, combinedCaps)).data;
+
+      try {
+        should.not.exist(status);
+        should.not.exist(sessionId);
+        value.sessionId.should.exist;
+        value.capabilities.should.deep.equal({ ...(0, _utils.removeAppiumPrefixes)(caps),
+          w3cParam: 'w3cParam'
+        });
+      } finally {
+        await _axios.default.delete(`${baseUrl}/${value.sessionId}`);
+      }
+    });
+    it('should reject bad automation name with an appropriate error', async function () {
+      const w3cCaps = {
+        capabilities: {
+          alwaysMatch: { ...caps,
+            'appium:automationName': 'BadAutomationName'
+          }
+        }
+      };
+      await _axios.default.post(baseUrl, w3cCaps).should.eventually.be.rejectedWith(/500/);
+    });
+    it('should accept capabilities that are provided in the firstMatch array', async function () {
+      const w3cCaps = {
+        capabilities: {
+          alwaysMatch: {},
+          firstMatch: [{}, { ...caps
+          }]
+        }
+      };
+      const {
+        value,
+        sessionId,
+        status
+      } = (await _axios.default.post(baseUrl, w3cCaps)).data;
+
+      try {
+        should.not.exist(status);
+        should.not.exist(sessionId);
+        value.capabilities.should.deep.equal((0, _utils.removeAppiumPrefixes)(caps));
+      } finally {
+        await _axios.default.delete(`${baseUrl}/${value.sessionId}`);
+      }
+    });
+    it('should not fall back to MJSONWP if w3c caps are invalid', async function () {
+      const combinedCaps = {
+        desiredCapabilities: { ...caps
+        },
+        capabilities: {
+          alwaysMatch: {},
+          firstMatch: [{}, { ...caps,
+            platformName: null,
+            'appium:automationName': null,
+            'appium:deviceName': null
+          }]
+        }
+      };
+      const res = await _axios.default.post(baseUrl, combinedCaps, {
+        validateStatus: null
+      });
+      res.status.should.eql(400);
+      res.data.value.error.should.match(/invalid argument/);
+    });
+    it('should not fall back to MJSONWP even if Inner Driver is not ready for W3C', async function () {
+      const combinedCaps = {
+        desiredCapabilities: { ...caps
+        },
+        capabilities: {
+          alwaysMatch: { ...caps,
+            'appium:deviceName': 'Fake'
+          }
+        }
+      };
+
+      const createSessionStub = _sinon.default.stub(FakeDriver.prototype, 'createSession').callsFake(async function (jsonwpCaps) {
+        const res = await _baseDriver.BaseDriver.prototype.createSession.call(this, jsonwpCaps);
+        this.protocol.should.equal('MJSONWP');
+        return res;
+      });
+
+      const res = await _axios.default.post(baseUrl, combinedCaps, {
+        validateStatus: null
+      });
+      const {
+        data,
+        status
+      } = res;
+      status.should.eql(500);
+      data.value.message.should.match(/older capabilities/);
+      createSessionStub.restore();
+    });
+    it('should allow drivers to update the method map with new routes and commands', async function () {
+      let driver = await (0, _webdriverio.remote)({ ...wdOpts,
+        capabilities: caps
+      });
+      const {
+        sessionId
+      } = driver;
+
+      try {
+        await _axios.default.post(`${baseUrl}/${sessionId}/fakedriver`, {
+          thing: {
+            yes: 'lolno'
+          }
+        });
+        (await _axios.default.get(`${baseUrl}/${sessionId}/fakedriver`)).data.value.should.eql({
+          yes: 'lolno'
+        });
+      } finally {
+        await driver.deleteSession();
+      }
+    });
+  });
+});
+describe.skip('Logsink', function () {
+  let server = null;
+  let logs = [];
+
+  let logHandler = function (level, message) {
+    logs.push([level, message]);
+  };
+
+  let args = {
+    port: TEST_PORT,
+    host: _helpers.TEST_HOST,
+    appiumHome: _extensionConfig.DEFAULT_APPIUM_HOME,
+    logHandler
+  };
+  before(async function () {
+    server = await (0, _main.main)(args);
+  });
+  after(async function () {
+    await server.close();
+  });
+  it('should send logs to a logHandler passed in by a parent package', function () {
+    logs.length.should.be.above(1);
+    let welcomeIndex = logs[0][1].includes('versions of node') ? 1 : 0;
+    logs[welcomeIndex].length.should.equal(2);
+    logs[welcomeIndex][1].should.include('Welcome to Appium');
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/driver-e2e-specs.js"],"names":["TEST_SERVER","TEST_PORT","sillyWebServerPort","sillyWebServerHost","FAKE_ARGS","FAKE_DRIVER_ARGS","driver","fake","shouldStartServer","process","env","USE_RUNNING_SERVER","caps","W3C_PREFIXED_CAPS","wdOpts","hostname","TEST_HOST","port","connectionRetryCount","describe","server","appiumHome","DEFAULT_APPIUM_HOME","FakeDriver","baseUrl","FAKE_DRIVER_DIR","path","join","PROJECT_ROOT","before","driverList","driverCommand","showInstalled","DRIVER_TYPE","_","has","installType","INSTALL_TYPE_LOCAL","config","DriverConfig","getInstance","require","serverStart","after","serverClose","args","host","close","it","data","axios","get","should","eql","fakedriver","capabilities","sessionId","not","exist","value","deleteSession","be","a","getTitle","eventually","rejectedWith","driver1","driver2","equal","uniqueCaps","clone","rejected","localCaps","Object","assign","B","delay","getPageSource","w3cCaps","alwaysMatch","platformName","firstMatch","TEST_FAKE_APP","status","post","string","deep","automationName","deviceName","app","screenshotStatus","screenshotValue","url","match","script","delete","badW3Ccaps","combinedCaps","jsonwpParam","w3cParam","desiredCapabilities","res","validateStatus","error","createSessionStub","sinon","stub","prototype","callsFake","jsonwpCaps","BaseDriver","createSession","call","protocol","message","restore","thing","yes","skip","logs","logHandler","level","push","length","above","welcomeIndex","includes","include"],"mappings":"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","sourcesContent":["// transpile:mocha\n\nimport _ from 'lodash';\nimport path from 'path';\nimport B from 'bluebird';\nimport axios from 'axios';\nimport { remote as wdio } from 'webdriverio';\nimport { main as appiumServer } from '../lib/main';\nimport { DEFAULT_APPIUM_HOME, INSTALL_TYPE_LOCAL, DRIVER_TYPE } from '../lib/extension-config';\nimport { W3C_PREFIXED_CAPS, TEST_FAKE_APP, TEST_HOST, getTestPort, PROJECT_ROOT } from './helpers';\nimport { BaseDriver } from '@appium/base-driver';\nimport DriverConfig from '../lib/driver-config';\nimport { runExtensionCommand } from '../lib/cli/extension';\nimport { removeAppiumPrefixes } from '../lib/utils';\nimport sinon from 'sinon';\n\n\nlet TEST_SERVER;\nlet TEST_PORT;\nconst sillyWebServerPort = 1234;\nconst sillyWebServerHost = 'hey';\nconst FAKE_ARGS = {sillyWebServerPort, sillyWebServerHost};\nconst FAKE_DRIVER_ARGS = {driver: {fake: FAKE_ARGS}};\nconst shouldStartServer = process.env.USE_RUNNING_SERVER !== '0';\nconst caps = W3C_PREFIXED_CAPS;\nconst wdOpts = {\n  hostname: TEST_HOST,\n  port: null,\n  connectionRetryCount: 0,\n};\n\ndescribe('FakeDriver - via HTTP', function () {\n  let server = null;\n  const appiumHome = DEFAULT_APPIUM_HOME;\n  // since we update the FakeDriver.prototype below, make sure we update the FakeDriver which is\n  // actually going to be required by Appium\n  let FakeDriver = null;\n  let baseUrl;\n  const FAKE_DRIVER_DIR = path.join(PROJECT_ROOT, 'packages', 'fake-driver');\n  before(async function () {\n    wdOpts.port = TEST_PORT = await getTestPort();\n    TEST_SERVER = `http://${TEST_HOST}:${TEST_PORT}`;\n    baseUrl = `${TEST_SERVER}/session`;\n    // first ensure we have fakedriver installed\n    const driverList = await runExtensionCommand({\n      appiumHome,\n      driverCommand: 'list',\n      showInstalled: true,\n    }, DRIVER_TYPE);\n    if (!_.has(driverList, 'fake')) {\n      await runExtensionCommand({\n        appiumHome,\n        driverCommand: 'install',\n        driver: FAKE_DRIVER_DIR,\n        installType: INSTALL_TYPE_LOCAL,\n      }, DRIVER_TYPE);\n    }\n\n    const config = DriverConfig.getInstance(appiumHome);\n    FakeDriver = config.require('fake');\n    // then start server if we need to\n    await serverStart();\n  });\n\n  after(async function () {\n    await serverClose();\n  });\n\n  async function serverStart (args = {}) {\n    args = {port: TEST_PORT, host: TEST_HOST, appiumHome, ...args};\n    if (shouldStartServer) {\n      server = await appiumServer(args);\n    }\n  }\n\n  async function serverClose () {\n    if (server) {\n      await server.close();\n    }\n  }\n\n  describe('server updating', function () {\n    it('should allow drivers to update the server in arbitrary ways', async function () {\n      const {data} = await axios.get(`${TEST_SERVER}/fakedriver`);\n      data.should.eql({fakedriver: 'fakeResponse'});\n    });\n  });\n\n  describe('cli args handling for empty args', function () {\n    it('should not recieve user cli args if none passed in', async function () {\n      let driver = await wdio({...wdOpts, capabilities: caps});\n      const {sessionId} = driver;\n      try {\n        const {data} = await axios.get(`${baseUrl}/${sessionId}/fakedriverargs`);\n        should.not.exist(data.value.sillyWebServerPort);\n        should.not.exist(data.value.sillyWebServerHost);\n      } finally {\n        await driver.deleteSession();\n      }\n    });\n  });\n\n  describe('cli args handling for passed in args', function () {\n    before(async function () {\n      await serverClose();\n      await serverStart(FAKE_DRIVER_ARGS);\n    });\n    after(async function () {\n      await serverClose();\n      await serverStart();\n    });\n    it('should receive user cli args from a driver if arguments were passed in', async function () {\n      let driver = await wdio({...wdOpts, capabilities: caps});\n      const {sessionId} = driver;\n      try {\n        const {data} = await axios.get(`${baseUrl}/${sessionId}/fakedriverargs`);\n        data.value.sillyWebServerPort.should.eql(sillyWebServerPort);\n        data.value.sillyWebServerHost.should.eql(sillyWebServerHost);\n      } finally {\n        await driver.deleteSession();\n      }\n    });\n  });\n\n  describe('session handling', function () {\n    it('should start and stop a session and not allow commands after session stopped', async function () {\n      let driver = await wdio({...wdOpts, capabilities: caps});\n      should.exist(driver.sessionId);\n      driver.sessionId.should.be.a('string');\n      await driver.deleteSession();\n      await driver.getTitle().should.eventually.be.rejectedWith(/terminated/);\n    });\n\n    it('should be able to run two FakeDriver sessions simultaneously', async function () {\n      let driver1 = await wdio({...wdOpts, capabilities: caps});\n      should.exist(driver1.sessionId);\n      driver1.sessionId.should.be.a('string');\n      let driver2 = await wdio({...wdOpts, capabilities: caps});\n      should.exist(driver2.sessionId);\n      driver2.sessionId.should.be.a('string');\n      driver2.sessionId.should.not.equal(driver1.sessionId);\n      await driver1.deleteSession();\n      await driver2.deleteSession();\n    });\n\n    it('should not be able to run two FakeDriver sessions simultaneously when one is unique', async function () {\n      let uniqueCaps = _.clone(caps);\n      uniqueCaps['appium:uniqueApp'] = true;\n      let driver1 = await wdio({...wdOpts, capabilities: uniqueCaps});\n      should.exist(driver1.sessionId);\n      driver1.sessionId.should.be.a('string');\n      await wdio({...wdOpts, capabilities: caps}).should.eventually.be.rejected;\n      await driver1.deleteSession();\n    });\n\n    it('should use the newCommandTimeout of the inner Driver on session creation', async function () {\n      let localCaps = Object.assign({\n        'appium:newCommandTimeout': 0.25,\n      }, caps);\n      let driver = await wdio({...wdOpts, capabilities: localCaps});\n      should.exist(driver.sessionId);\n\n      await B.delay(250);\n      await driver.getPageSource().should.eventually.be.rejectedWith(/terminated/);\n    });\n\n    it('should accept valid W3C capabilities and start a W3C session', async function () {\n      // Try with valid capabilities and check that it returns a session ID\n      const w3cCaps = {\n        capabilities: {\n          alwaysMatch: {'appium:automationName': 'Fake', platformName: 'Fake'},\n          firstMatch: [{'appium:deviceName': 'Fake', 'appium:app': TEST_FAKE_APP}],\n        }\n      };\n\n      // Create the session\n      const {status, value, sessionId} = (await axios.post(baseUrl, w3cCaps)).data;\n      try {\n        should.not.exist(status); // Test that it's a W3C session by checking that 'status' is not in the response\n        should.not.exist(sessionId);\n        value.sessionId.should.be.a.string;\n        value.should.exist;\n        value.capabilities.should.deep.equal({\n          automationName: 'Fake',\n          platformName: 'Fake',\n          deviceName: 'Fake',\n          app: TEST_FAKE_APP,\n        });\n\n        // Now use that sessionId to call /screenshot\n        const {status: screenshotStatus, value: screenshotValue} = (await axios({url: `${baseUrl}/${value.sessionId}/screenshot`})).data;\n        should.not.exist(screenshotStatus);\n        screenshotValue.should.match(/^iVBOR/); // should be a png\n\n        // Now use that sessionID to call an arbitrary W3C-only endpoint that isn't implemented to see if it responds with correct error\n        await axios.post(\n          `${baseUrl}/${value.sessionId}/execute/async`,\n          {script: '', args: ['a']}).should.eventually.be.rejectedWith(/405/);\n      } finally {\n        // End session\n        await axios.delete(`${baseUrl}/${value.sessionId}`);\n      }\n    });\n\n    it('should reject invalid W3C capabilities and respond with a 400 Bad Parameters error', async function () {\n      const badW3Ccaps = {\n        capabilities: {\n          alwaysMatch: {},\n          firstMatch: [{'appium:deviceName': 'Fake', 'appium:app': TEST_FAKE_APP}],\n        }\n      };\n\n      await axios.post(baseUrl, badW3Ccaps).should.eventually.be.rejectedWith(/400/);\n    });\n\n    it('should accept a combo of W3C and JSONWP capabilities but completely ignore JSONWP', async function () {\n      const combinedCaps = {\n        'desiredCapabilities': {\n          ...caps,\n          jsonwpParam: 'jsonwpParam',\n        },\n        'capabilities': {\n          'alwaysMatch': {...caps},\n          'firstMatch': [{\n            'appium:w3cParam': 'w3cParam',\n          }],\n        }\n      };\n\n      const {status, value, sessionId} = (await axios.post(baseUrl, combinedCaps)).data;\n      try {\n        should.not.exist(status); // If it's a W3C session, should not respond with 'status'\n        should.not.exist(sessionId);\n        value.sessionId.should.exist;\n        value.capabilities.should.deep.equal({\n          ...removeAppiumPrefixes(caps),\n          w3cParam: 'w3cParam',\n        });\n      } finally {\n        // End session\n        await axios.delete(`${baseUrl}/${value.sessionId}`);\n      }\n    });\n\n    it('should reject bad automation name with an appropriate error', async function () {\n      const w3cCaps = {\n        capabilities: {\n          alwaysMatch: {\n            ...caps,\n            'appium:automationName': 'BadAutomationName',\n          },\n        },\n      };\n      await axios.post(baseUrl, w3cCaps).should.eventually.be.rejectedWith(/500/);\n    });\n\n    it('should accept capabilities that are provided in the firstMatch array', async function () {\n      const w3cCaps = {\n        capabilities: {\n          alwaysMatch: {},\n          firstMatch: [{}, {\n            ...caps\n          }],\n        },\n      };\n      const {value, sessionId, status} = (await axios.post(baseUrl, w3cCaps)).data;\n      try {\n        should.not.exist(status);\n        should.not.exist(sessionId);\n        value.capabilities.should.deep.equal(removeAppiumPrefixes(caps));\n      } finally {\n        // End session\n        await axios.delete(`${baseUrl}/${value.sessionId}`);\n      }\n    });\n\n    it('should not fall back to MJSONWP if w3c caps are invalid', async function () {\n      const combinedCaps = {\n        desiredCapabilities: {\n          ...caps,\n        },\n        capabilities: {\n          alwaysMatch: {},\n          firstMatch: [{}, {\n            ...caps,\n            platformName: null,\n            'appium:automationName': null,\n            'appium:deviceName': null,\n          }],\n        },\n      };\n      const res = (await axios.post(baseUrl, combinedCaps, {validateStatus: null}));\n      res.status.should.eql(400);\n      res.data.value.error.should.match(/invalid argument/);\n    });\n\n    it('should not fall back to MJSONWP even if Inner Driver is not ready for W3C', async function () {\n      const combinedCaps = {\n        desiredCapabilities: {\n          ...caps,\n        },\n        capabilities: {\n          alwaysMatch: {\n            ...caps,\n            'appium:deviceName': 'Fake',\n          },\n        },\n      };\n      const createSessionStub = sinon.stub(FakeDriver.prototype, 'createSession').callsFake(async function (jsonwpCaps) {\n        const res = await BaseDriver.prototype.createSession.call(this, jsonwpCaps);\n        this.protocol.should.equal('MJSONWP');\n        return res;\n      });\n\n      const res = (await axios.post(baseUrl, combinedCaps, {validateStatus: null}));\n      const {data, status} = res;\n      status.should.eql(500);\n      data.value.message.should.match(/older capabilities/);\n\n      createSessionStub.restore();\n    });\n\n    it('should allow drivers to update the method map with new routes and commands', async function () {\n      let driver = await wdio({...wdOpts, capabilities: caps});\n      const {sessionId} = driver;\n      try {\n        await axios.post(`${baseUrl}/${sessionId}/fakedriver`, {thing: {yes: 'lolno'}});\n        (await axios.get(`${baseUrl}/${sessionId}/fakedriver`)).data.value.should.eql({yes: 'lolno'});\n      } finally {\n        await driver.deleteSession();\n      }\n    });\n  });\n});\n\n// TODO this test only works if the log has not previously been initialized in the same process.\n// there seems to be some global state that is not cleaned up between tests.\ndescribe.skip('Logsink', function () {\n  let server = null;\n  let logs = [];\n  let logHandler = function (level, message) {\n    logs.push([level, message]);\n  };\n  let args = {\n    port: TEST_PORT,\n    host: TEST_HOST,\n    appiumHome: DEFAULT_APPIUM_HOME,\n    logHandler,\n  };\n\n  before(async function () {\n    server = await appiumServer(args);\n  });\n\n  after(async function () {\n    await server.close();\n  });\n\n  it('should send logs to a logHandler passed in by a parent package', function () {\n    logs.length.should.be.above(1);\n    let welcomeIndex = logs[0][1].includes('versions of node') ? 1 : 0;\n    logs[welcomeIndex].length.should.equal(2);\n    logs[welcomeIndex][1].should.include('Welcome to Appium');\n  });\n});\n"],"file":"test/driver-e2e-specs.js","sourceRoot":"../.."}