@appium/base-driver 8.3.0 → 8.3.1

package/test/basedriver/helpers-e2e-specs.js

@@ -1,187 +0,0 @@
-import path from 'path';
-import url from 'url';
-import { fs } from '@appium/support';
-import { configureApp } from '../../lib/basedriver/helpers';
-import http from 'http';
-import finalhandler from 'finalhandler';
-import serveStatic from 'serve-static';
-import contentDisposition from 'content-disposition';
-import B from 'bluebird';
-import {TEST_HOST, getTestPort} from '../helpers';
-
-
-function getFixture (file) {
-  // XXX: __dirname disallowed in native ESM
-  return path.resolve(__dirname, '..', '..', '..', 'test', 'basedriver', 'fixtures', file);
-}
-
-describe('app download and configuration', function () {
-  describe('configureApp', function () {
-    it('should get the path for a local .app', async function () {
-      let newAppPath = await configureApp(getFixture('FakeIOSApp.app'), '.app');
-      newAppPath.should.contain('FakeIOSApp.app');
-      let contents = await fs.readFile(newAppPath, 'utf8');
-      contents.should.eql('this is not really an app\n');
-    });
-    it('should get the path for a local .apk', async function () {
-      let newAppPath = await configureApp(getFixture('FakeAndroidApp.apk'), '.apk');
-      newAppPath.should.contain('FakeAndroidApp.apk');
-      let contents = await fs.readFile(newAppPath, 'utf8');
-      contents.should.eql('this is not really an apk\n');
-    });
-    it('should unzip and get the path for a local .app.zip', async function () {
-      let newAppPath = await configureApp(getFixture('FakeIOSApp.app.zip'), '.app');
-      newAppPath.should.contain('FakeIOSApp.app');
-      let contents = await fs.readFile(newAppPath, 'utf8');
-      contents.should.eql('this is not really an app\n');
-    });
-    it('should unzip and get the path for a local .ipa', async function () {
-      let newAppPath = await configureApp(getFixture('FakeIOSApp.ipa'), '.app');
-      newAppPath.should.contain('FakeIOSApp.app');
-      let contents = await fs.readFile(newAppPath, 'utf8');
-      contents.should.eql('this is not really an app\n');
-    });
-    it('should fail for a bad zip file', async function () {
-      await configureApp(getFixture('BadZippedApp.zip'), '.app')
-        .should.be.rejectedWith(/PK/);
-    });
-    it('should fail if extensions do not match', async function () {
-      await configureApp(getFixture('FakeIOSApp.app'), '.wrong')
-        .should.be.rejectedWith(/did not have extension/);
-    });
-    it('should fail if zip file does not contain an app whose extension matches', async function () {
-      await configureApp(getFixture('FakeIOSApp.app.zip'), '.wrong')
-        .should.be.rejectedWith(/did not have extension/);
-    });
-    describe('should download an app from the web', function () {
-      let port;
-      let serverUrl;
-
-      before(async function () {
-        port = await getTestPort(true);
-        serverUrl = `http://${TEST_HOST}:${port}`;
-      });
-
-      describe('server not available', function () {
-        it('should handle server not available', async function () {
-          await configureApp(`${serverUrl}/FakeIOSApp.app.zip`, '.app')
-            .should.eventually.be.rejectedWith(/ECONNREFUSED/);
-        });
-      });
-      describe('server available', function () {
-        // use a local server so there is no dependency on the internet
-        let server;
-        before(function () {
-          const dir = path.resolve(__dirname, '..', '..', '..', 'test', 'basedriver', 'fixtures');
-          const serve = serveStatic(dir, {
-            index: false,
-            setHeaders: (res, path) => {
-              res.setHeader('Content-Disposition', contentDisposition(path));
-            },
-          });
-
-          server = http.createServer(function (req, res) {
-            if (req.url.indexOf('missing') !== -1) {
-              res.writeHead(404);
-              res.end();
-              return;
-            }
-            // for testing zip file content types
-            const contentType = new URLSearchParams(url.parse(req.url).search).get('content-type');
-            if (contentType !== null) {
-              res.setHeader('content-type', contentType);
-            }
-            serve(req, res, finalhandler(req, res));
-          });
-          const close = server.close.bind(server);
-          server.close = async function () {
-            // pause a moment or we get ECONRESET errors
-            await B.delay(1000);
-            return await new B((resolve, reject) => {
-              server.on('close', resolve);
-              close((err) => {
-                if (err) reject(err); // eslint-disable-line curly
-              });
-            });
-          };
-          server.listen(port);
-        });
-        after(async function () {
-          await server.close();
-        });
-
-        it('should download zip file', async function () {
-          let newAppPath = await configureApp(`${serverUrl}/FakeIOSApp.app.zip`, '.app');
-          newAppPath.should.contain('FakeIOSApp.app');
-          let contents = await fs.readFile(newAppPath, 'utf8');
-          contents.should.eql('this is not really an app\n');
-        });
-        it('should download zip file with query string', async function () {
-          let newAppPath = await configureApp(`${serverUrl}/FakeIOSApp.app.zip?sv=abc&sr=def`, '.app');
-          newAppPath.should.contain('.app');
-          let contents = await fs.readFile(newAppPath, 'utf8');
-          contents.should.eql('this is not really an app\n');
-        });
-        it('should download an app file', async function () {
-          let newAppPath = await configureApp(`${serverUrl}/FakeIOSApp.app`, '.app');
-          newAppPath.should.contain('.app');
-          let contents = await fs.readFile(newAppPath, 'utf8');
-          contents.should.eql('this is not really an app\n');
-        });
-        it('should accept multiple extensions', async function () {
-          let newAppPath = await configureApp(`${serverUrl}/FakeIOSApp.app.zip`, ['.app', '.aab']);
-          newAppPath.should.contain('FakeIOSApp.app');
-          let contents = await fs.readFile(newAppPath, 'utf8');
-          contents.should.eql('this is not really an app\n');
-        });
-        it('should download an apk file', async function () {
-          let newAppPath = await configureApp(`${serverUrl}/FakeAndroidApp.apk`, '.apk');
-          newAppPath.should.contain('.apk');
-          let contents = await fs.readFile(newAppPath, 'utf8');
-          contents.should.eql('this is not really an apk\n');
-        });
-        it('should handle zip file that cannot be downloaded', async function () {
-          await configureApp(`${serverUrl}/missing/FakeIOSApp.app.zip`, '.app')
-            .should.eventually.be.rejected;
-        });
-        it('should handle invalid protocol', async function () {
-          await configureApp('file://C:/missing/FakeIOSApp.app.zip', '.app')
-            .should.eventually.be.rejectedWith(/is not supported/);
-          await configureApp(`ftp://${TEST_HOST}:${port}/missing/FakeIOSApp.app.zip`, '.app')
-            .should.eventually.be.rejectedWith(/is not supported/);
-        });
-        it('should handle missing file in Windows path format', async function () {
-          await configureApp('C:\\missing\\FakeIOSApp.app.zip', '.app')
-            .should.eventually.be.rejectedWith(/does not exist or is not accessible/);
-        });
-        it('should recognize zip mime types and unzip the downloaded file', async function () {
-          let newAppPath = await configureApp(`${serverUrl}/FakeAndroidApp.asd?content-type=${encodeURIComponent('application/zip')}`, '.apk');
-          newAppPath.should.contain('FakeAndroidApp.apk');
-          newAppPath.should.not.contain('.asd');
-          let contents = await fs.readFile(newAppPath, 'utf8');
-          contents.should.eql('this is not really an apk\n');
-        });
-        it('should recognize zip mime types with parameter and unzip the downloaded file', async function () {
-          let newAppPath = await configureApp(`${serverUrl}/FakeAndroidApp.asd?content-type=${encodeURIComponent('application/zip; parameter=value')}`, '.apk');
-          newAppPath.should.contain('FakeAndroidApp.apk');
-          newAppPath.should.not.contain('.asd');
-          let contents = await fs.readFile(newAppPath, 'utf8');
-          contents.should.eql('this is not really an apk\n');
-        });
-        it('should recognize zip mime types and unzip the downloaded file with query string', async function () {
-          let newAppPath = await configureApp(`${serverUrl}/FakeAndroidApp.asd?content-type=${encodeURIComponent('application/zip')}&sv=abc&sr=def`, '.apk');
-          newAppPath.should.contain('FakeAndroidApp.apk');
-          newAppPath.should.not.contain('.asd');
-          let contents = await fs.readFile(newAppPath, 'utf8');
-          contents.should.eql('this is not really an apk\n');
-        });
-        it('should treat an unknown mime type as an app', async function () {
-          let newAppPath = await configureApp(`${serverUrl}/FakeAndroidApp.apk?content-type=${encodeURIComponent('application/bip')}`, '.apk');
-          newAppPath.should.contain('.apk');
-          let contents = await fs.readFile(newAppPath, 'utf8');
-          contents.should.eql('this is not really an apk\n');
-        });
-      });
-    });
-  });
-});

package/test/basedriver/helpers-specs.js

@@ -1,137 +0,0 @@
-import { zip, fs, tempDir } from '@appium/support';
-import { configureApp, isPackageOrBundle, duplicateKeys, parseCapsArray } from '../../lib/basedriver/helpers';
-import sinon from 'sinon';
-
-
-describe('helpers', function () {
-  describe('#isPackageOrBundle', function () {
-    it('should accept packages and bundles', function () {
-      isPackageOrBundle('io.appium.testapp').should.be.true;
-    });
-    it('should not accept non-packages or non-bundles', function () {
-      isPackageOrBundle('foo').should.be.false;
-      isPackageOrBundle('/path/to/an.app').should.be.false;
-      isPackageOrBundle('/path/to/an.apk').should.be.false;
-    });
-  });
-
-  describe('#duplicateKeys', function () {
-    it('should translate key in an object', function () {
-      duplicateKeys({'foo': 'hello world'}, 'foo', 'bar').should.eql({'foo': 'hello world', 'bar': 'hello world'});
-    });
-    it('should translate key in an object within an object', function () {
-      duplicateKeys({'key': {'foo': 'hello world'}}, 'foo', 'bar').should.eql({'key': {'foo': 'hello world', 'bar': 'hello world'}});
-    });
-    it('should translate key in an object with an array', function () {
-      duplicateKeys([
-        {'key': {'foo': 'hello world'}},
-        {'foo': 'HELLO WORLD'}
-      ], 'foo', 'bar').should.eql([
-        {'key': {'foo': 'hello world', 'bar': 'hello world'}},
-        {'foo': 'HELLO WORLD', 'bar': 'HELLO WORLD'}
-      ]);
-    });
-    it('should duplicate both keys', function () {
-      duplicateKeys({
-        'keyOne': {
-          'foo': 'hello world',
-        },
-        'keyTwo': {
-          'bar': 'HELLO WORLD',
-        },
-      }, 'foo', 'bar').should.eql({
-        'keyOne': {
-          'foo': 'hello world',
-          'bar': 'hello world',
-        },
-        'keyTwo': {
-          'bar': 'HELLO WORLD',
-          'foo': 'HELLO WORLD',
-        }
-      });
-    });
-    it('should not do anything to primitives', function () {
-      [0, 1, -1, true, false, null, undefined, '', 'Hello World'].forEach((item) => {
-        should.equal(duplicateKeys(item), item);
-      });
-    });
-    it('should rename keys on big complex objects', function () {
-      const input = [
-        {'foo': 'bar'},
-        {
-          hello: {
-            world: {
-              'foo': 'BAR',
-            }
-          },
-          foo: 'bahr'
-        },
-        'foo',
-        null,
-        0
-      ];
-      const expectedOutput = [
-        {'foo': 'bar', 'FOO': 'bar'},
-        {
-          hello: {
-            world: {
-              'foo': 'BAR',
-              'FOO': 'BAR',
-            }
-          },
-          foo: 'bahr',
-          FOO: 'bahr'
-        },
-        'foo',
-        null,
-        0
-      ];
-      duplicateKeys(input, 'foo', 'FOO').should.deep.equal(expectedOutput);
-    });
-  });
-
-  describe('#configureApp', function () {
-    let sandbox;
-
-    beforeEach(function () {
-      sandbox = sinon.createSandbox();
-      sandbox.stub(zip, 'extractAllTo').resolves();
-      sandbox.stub(zip, 'assertValidZip').resolves();
-      sandbox.stub(fs, 'mv').resolves();
-      sandbox.stub(fs, 'stat').resolves({
-        isFile: () => true,
-        isDirectory: () => false,
-      });
-      sandbox.stub(fs, 'exists').resolves(true);
-      sandbox.stub(fs, 'hash').resolves('0xDEADBEEF');
-      sandbox.stub(fs, 'glob').resolves(['/path/to/an.apk']);
-      sandbox.stub(fs, 'rimraf').resolves();
-      sandbox.stub(tempDir, 'openDir').resolves('/some/dir');
-    });
-
-    afterEach(function () {
-      sandbox.restore();
-    });
-
-    it('should pass "useSystemUnzip" flag through to @appium/support', async function () {
-      await configureApp('/path/to/an.apk.zip', '.apk');
-      zip.extractAllTo.getCall(0).lastArg.useSystemUnzip.should.be.true;
-    });
-  });
-});
-
-describe('parseCapsArray', function () {
-  it('should parse string into array', function () {
-    parseCapsArray('/tmp/my/app.zip').should.eql(['/tmp/my/app.zip']);
-  });
-  it('should parse array as string into array', function () {
-    parseCapsArray('["/tmp/my/app.zip"]').should.eql(['/tmp/my/app.zip']);
-    parseCapsArray('["/tmp/my/app.zip","/tmp/my/app2.zip"]').should.eql([
-      '/tmp/my/app.zip',
-      '/tmp/my/app2.zip'
-    ]);
-  });
-  it('should return an array without change', function () {
-    parseCapsArray(['a', 'b']).should.eql(['a', 'b']);
-  });
-});

package/test/basedriver/timeout-specs.js

@@ -1,128 +0,0 @@
-import BaseDriver from '../../lib';
-import { createSandbox } from 'sinon';
-
-describe('timeout', function () {
-  let driver = new BaseDriver();
-  let implicitWaitSpy;
-  let sandbox;
-  beforeEach(function () {
-    sandbox = createSandbox();
-    driver.implicitWaitMs = 0;
-    implicitWaitSpy = sandbox.spy(driver, 'setImplicitWait');
-  });
-  afterEach(function () {
-    sandbox.restore();
-  });
-  describe('timeouts', function () {
-    describe('errors', function () {
-      it('should throw an error if something random is sent', async function () {
-        await driver.timeouts('random timeout', 'howdy').should.eventually.be.rejected;
-      });
-      it('should throw an error if timeout is negative', async function () {
-        await driver.timeouts('random timeout', -42).should.eventually.be.rejected;
-      });
-      it('should throw an errors if timeout type is unknown', async function () {
-        await driver.timeouts('random timeout', 42).should.eventually.be.rejected;
-      });
-      it('should throw an error if something random is sent to scriptDuration', async function () {
-        await driver.timeouts(undefined, undefined, 123, undefined, undefined).should.eventually.be.rejected;
-      });
-      it('should throw an error if something random is sent to pageLoadDuration', async function () {
-        await driver.timeouts(undefined, undefined, undefined, 123, undefined).should.eventually.be.rejected;
-      });
-    });
-    describe('implicit wait', function () {
-      it('should call setImplicitWait when given an integer', async function () {
-        await driver.timeouts('implicit', 42);
-        implicitWaitSpy.calledOnce.should.be.true;
-        implicitWaitSpy.firstCall.args[0].should.equal(42);
-        driver.implicitWaitMs.should.eql(42);
-      });
-      it('should call setImplicitWait when given a string', async function () {
-        await driver.timeouts('implicit', '42');
-        implicitWaitSpy.calledOnce.should.be.true;
-        implicitWaitSpy.firstCall.args[0].should.equal(42);
-        driver.implicitWaitMs.should.eql(42);
-      });
-      it('should call setImplicitWait when given an integer to implicitDuration', async function () {
-        await driver.timeouts(undefined, undefined, undefined, undefined, 42);
-        implicitWaitSpy.calledOnce.should.be.true;
-        implicitWaitSpy.firstCall.args[0].should.equal(42);
-        driver.implicitWaitMs.should.eql(42);
-      });
-      it('should call setImplicitWait when given a string to implicitDuration', async function () {
-        await driver.timeouts(undefined, undefined, undefined, undefined, '42');
-        implicitWaitSpy.calledOnce.should.be.true;
-        implicitWaitSpy.firstCall.args[0].should.equal(42);
-        driver.implicitWaitMs.should.eql(42);
-      });
-    });
-  });
-  describe('implicitWait', function () {
-    it('should call setImplicitWait when given an integer', async function () {
-      await driver.implicitWait(42);
-      implicitWaitSpy.calledOnce.should.be.true;
-      implicitWaitSpy.firstCall.args[0].should.equal(42);
-      driver.implicitWaitMs.should.eql(42);
-    });
-    it('should call setImplicitWait when given a string', async function () {
-      await driver.implicitWait('42');
-      implicitWaitSpy.calledOnce.should.be.true;
-      implicitWaitSpy.firstCall.args[0].should.equal(42);
-      driver.implicitWaitMs.should.eql(42);
-    });
-    it('should throw an error if something random is sent', async function () {
-      await driver.implicitWait('howdy').should.eventually.be.rejected;
-    });
-    it('should throw an error if timeout is negative', async function () {
-      await driver.implicitWait(-42).should.eventually.be.rejected;
-    });
-  });
-
-  describe('set implicit wait', function () {
-    it('should set the implicit wait with an integer', function () {
-      driver.setImplicitWait(42);
-      driver.implicitWaitMs.should.eql(42);
-    });
-    describe('with managed driver', function () {
-      let managedDriver1 = new BaseDriver();
-      let managedDriver2 = new BaseDriver();
-      before(function () {
-        driver.addManagedDriver(managedDriver1);
-        driver.addManagedDriver(managedDriver2);
-      });
-      after(function () {
-        driver.managedDrivers = [];
-      });
-      it('should set the implicit wait on managed drivers', function () {
-        driver.setImplicitWait(42);
-        driver.implicitWaitMs.should.eql(42);
-        managedDriver1.implicitWaitMs.should.eql(42);
-        managedDriver2.implicitWaitMs.should.eql(42);
-      });
-    });
-  });
-  describe('set new command timeout', function () {
-    it('should set the new command timeout with an integer', function () {
-      driver.setNewCommandTimeout(42);
-      driver.newCommandTimeoutMs.should.eql(42);
-    });
-    describe('with managed driver', function () {
-      let managedDriver1 = new BaseDriver();
-      let managedDriver2 = new BaseDriver();
-      before(function () {
-        driver.addManagedDriver(managedDriver1);
-        driver.addManagedDriver(managedDriver2);
-      });
-      after(function () {
-        driver.managedDrivers = [];
-      });
-      it('should set the new command timeout on managed drivers', function () {
-        driver.setNewCommandTimeout(42);
-        driver.newCommandTimeoutMs.should.eql(42);
-        managedDriver1.newCommandTimeoutMs.should.eql(42);
-        managedDriver2.newCommandTimeoutMs.should.eql(42);
-      });
-    });
-  });
-});

package/test/basedriver/websockets-e2e-specs.js

@@ -1,75 +0,0 @@
-import _ from 'lodash';
-import { server, routeConfiguringFunction,
-         DEFAULT_WS_PATHNAME_PREFIX } from '../../lib';
-import { FakeDriver } from '../protocol/fake-driver';
-import WebSocket from 'ws';
-import B from 'bluebird';
-import {TEST_HOST, getTestPort} from '../helpers';
-
-
-describe('Websockets (e2e)', function () {
-  let baseServer;
-  let driver;
-  let port;
-  const SESSION_ID = 'foo';
-  const WS_DATA = 'Hello';
-
-  before(async function () {
-    driver = new FakeDriver();
-    driver.sessionId = SESSION_ID;
-    port = await getTestPort();
-    baseServer = await server({
-      routeConfiguringFunction: routeConfiguringFunction(driver),
-      port,
-    });
-  });
-  after(async function () {
-    await baseServer.close();
-  });
-
-  describe('web sockets support', function () {
-    it('should be able to add websocket handler and remove it', async function () {
-      const wss = new WebSocket.Server({
-        noServer: true,
-      });
-      wss.on('connection', (ws) => {
-        if (ws && ws.readyState === WebSocket.OPEN) {
-          ws.send(WS_DATA);
-        }
-      });
-      const previousListenerCount = baseServer.listenerCount('upgrade');
-      const endpoint = `${DEFAULT_WS_PATHNAME_PREFIX}/hello`;
-      const timeout = 5000;
-      await baseServer.addWebSocketHandler(endpoint, wss);
-      baseServer.listenerCount('upgrade').should.be.above(previousListenerCount);
-      _.keys(await baseServer.getWebSocketHandlers()).length.should.eql(1);
-      await new B((resolve, reject) => {
-        const client = new WebSocket(`ws://${TEST_HOST}:${port}${endpoint}`);
-        client.on('connection', (ws, req) => {
-          ws.should.not.be.empty;
-          req.connection.remoteAddress.should.not.be.empty;
-        });
-        client.on('message', (data) => {
-          data.should.eql(WS_DATA);
-          resolve();
-        });
-        client.on('error', reject);
-        setTimeout(() => reject(new Error('No websocket messages have been received after the timeout')),
-                   timeout);
-      });
-
-      (await baseServer.removeWebSocketHandler(endpoint)).should.be.true;
-      _.keys(await baseServer.getWebSocketHandlers()).length.should.eql(0);
-      await new B((resolve, reject) => {
-        const client = new WebSocket(`ws://${TEST_HOST}:${port}${endpoint}`);
-        client.on('message', (data) =>
-          reject(new Error(`No websocket messages are expected after the handler ` +
-                           `has been removed. '${data}' is received instead. `))
-        );
-        client.on('error', resolve);
-        setTimeout(resolve, timeout);
-      });
-      baseServer.listenerCount('upgrade').should.be.above(previousListenerCount);
-    });
-  });
-});