@appium/base-driver 8.2.3 → 8.3.1

package/build/test/unit/basedriver/capability.spec.js

@@ -0,0 +1,353 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+var _lib = _interopRequireWildcard(require("../../../lib"));
+
+var _logger = _interopRequireDefault(require("../../../lib/basedriver/logger"));
+
+var _sinon = require("sinon");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+describe('Desired Capabilities', function () {
+  let d;
+  let sandbox;
+  beforeEach(function () {
+    d = new _lib.default();
+    sandbox = (0, _sinon.createSandbox)();
+    sandbox.spy(d.log, 'warn');
+    sandbox.spy(_logger.default, 'warn');
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  it('should require platformName and deviceName', async function () {
+    await d.createSession({
+      firstMatch: [{}]
+    }).should.eventually.be.rejectedWith(_lib.errors.SessionNotCreatedError, /platformName/);
+  });
+  it('should require platformName', async function () {
+    await d.createSession({
+      alwaysMatch: {
+        'appium:deviceName': 'Delorean'
+      }
+    }).should.eventually.be.rejectedWith(_lib.errors.SessionNotCreatedError, /platformName/);
+  });
+  it('should not care about cap order', async function () {
+    await d.createSession(null, null, {
+      alwaysMatch: {
+        'appium:deviceName': 'Delorean',
+        platformName: 'iOS'
+      }
+    }).should.eventually.be.fulfilled;
+  });
+  it('should check required caps which are added to driver', async function () {
+    d.desiredCapConstraints = {
+      necessary: {
+        presence: true
+      },
+      proper: {
+        presence: true,
+        isString: true,
+        inclusion: ['Delorean', 'Reventon']
+      }
+    };
+    await d.createSession(null, null, {
+      alwaysMatch: {
+        'platformName': 'iOS',
+        'appium:deviceName': 'Delorean'
+      }
+    }).should.eventually.be.rejectedWith(_lib.errors.SessionNotCreatedError, /necessary.*proper/);
+  });
+  it('should check added required caps in addition to base', async function () {
+    d.desiredCapConstraints = {
+      necessary: {
+        presence: true
+      },
+      proper: {
+        presence: true,
+        isString: true,
+        inclusion: ['Delorean', 'Reventon']
+      }
+    };
+    await d.createSession(null, null, {
+      alwaysMatch: {
+        'appium:necessary': 'yup'
+      }
+    }).should.eventually.be.rejectedWith(_lib.errors.SessionNotCreatedError, /platformName/);
+  });
+  it('should accept extra capabilities', async function () {
+    await d.createSession(null, null, {
+      alwaysMatch: {
+        'platformName': 'iOS',
+        'appium:deviceName': 'Delorean',
+        'appium:extra': 'cheese',
+        'appium:hold the': 'sauce'
+      }
+    }).should.eventually.be.fulfilled;
+  });
+  it('should log the use of extra caps', async function () {
+    this.timeout(500);
+    await d.createSession(null, null, {
+      alwaysMatch: {
+        'platformName': 'iOS',
+        'appium:deviceName': 'Delorean',
+        'appium:extra': 'cheese',
+        'appium:hold the': 'sauce'
+      }
+    });
+    d.log.warn.should.have.been.called;
+  });
+  it('should be sensitive to the case of caps', async function () {
+    await d.createSession(null, null, {
+      alwaysMatch: {
+        'platformname': 'iOS',
+        'appium:deviceName': 'Delorean'
+      }
+    }).should.eventually.be.rejectedWith(_lib.errors.SessionNotCreatedError, /platformName/);
+  });
+  describe('boolean capabilities', function () {
+    it('should allow a string "false"', async function () {
+      await d.createSession(null, null, {
+        alwaysMatch: {
+          'platformName': 'iOS',
+          'appium:deviceName': 'Delorean',
+          'appium:noReset': 'false'
+        }
+      });
+      d.log.warn.should.have.been.called;
+      let sessions = await d.getSessions();
+      sessions[0].capabilities.noReset.should.eql(false);
+    });
+    it('should allow a string "true"', async function () {
+      await d.createSession(null, null, {
+        alwaysMatch: {
+          'platformName': 'iOS',
+          'appium:deviceName': 'Delorean',
+          'appium:noReset': 'true'
+        }
+      });
+      d.log.warn.should.have.been.called;
+      let sessions = await d.getSessions();
+      sessions[0].capabilities.noReset.should.eql(true);
+    });
+    it('should allow a string "true" in string capabilities', async function () {
+      await d.createSession(null, null, {
+        alwaysMatch: {
+          'platformName': 'iOS',
+          'appium:deviceName': 'Delorean',
+          'appium:language': 'true'
+        }
+      });
+      d.log.warn.should.not.have.been.called;
+      let sessions = await d.getSessions();
+      sessions[0].capabilities.language.should.eql('true');
+    });
+  });
+  describe('number capabilities', function () {
+    it('should allow a string "1"', async function () {
+      await d.createSession(null, null, {
+        alwaysMatch: {
+          'platformName': 'iOS',
+          'appium:deviceName': 'Delorean',
+          'appium:newCommandTimeout': '1'
+        }
+      });
+      d.log.warn.should.have.been.called;
+      let sessions = await d.getSessions();
+      sessions[0].capabilities.newCommandTimeout.should.eql(1);
+    });
+    it('should allow a string "1.1"', async function () {
+      await d.createSession(null, null, {
+        alwaysMatch: {
+          'platformName': 'iOS',
+          'appium:deviceName': 'Delorean',
+          'appium:newCommandTimeout': '1.1'
+        }
+      });
+      d.log.warn.should.have.been.called;
+      let sessions = await d.getSessions();
+      sessions[0].capabilities.newCommandTimeout.should.eql(1.1);
+    });
+    it('should allow a string "1" in string capabilities', async function () {
+      await d.createSession(null, null, {
+        alwaysMatch: {
+          'platformName': 'iOS',
+          'appium:deviceName': 'Delorean',
+          'appium:language': '1'
+        }
+      });
+      d.log.warn.should.not.have.been.called;
+      let sessions = await d.getSessions();
+      sessions[0].capabilities.language.should.eql('1');
+    });
+  });
+  it('should error if objects in caps', async function () {
+    await d.createSession(null, null, {
+      alwaysMatch: {
+        'platformName': {
+          a: 'iOS'
+        },
+        'appium:deviceName': 'Delorean'
+      }
+    }).should.eventually.be.rejectedWith(_lib.errors.SessionNotCreatedError, /platformName/i);
+  });
+  it('should check for deprecated caps', async function () {
+    this.timeout(500);
+    d.desiredCapConstraints = {
+      'lynx-version': {
+        deprecated: true
+      }
+    };
+    await d.createSession(null, null, {
+      alwaysMatch: {
+        'platformName': 'iOS',
+        'appium:deviceName': 'Delorean',
+        'appium:lynx-version': 5
+      }
+    });
+    _logger.default.warn.should.have.been.called;
+  });
+  it('should not warn if deprecated=false', async function () {
+    this.timeout(500);
+    d.desiredCapConstraints = {
+      'lynx-version': {
+        deprecated: false
+      }
+    };
+    await d.createSession(null, null, {
+      alwaysMatch: {
+        'platformName': 'iOS',
+        'appium:deviceName': 'Delorean',
+        'appium:lynx-version': 5
+      }
+    });
+    d.log.warn.should.not.have.been.called;
+  });
+  it('should not validate against null/undefined caps', async function () {
+    d.desiredCapConstraints = {
+      'foo': {
+        isString: true
+      }
+    };
+
+    try {
+      await d.createSession(null, null, {
+        alwaysMatch: {
+          platformName: 'iOS',
+          'appium:deviceName': 'Dumb',
+          'appium:foo': null
+        }
+      });
+    } finally {
+      await d.deleteSession();
+    }
+
+    await d.createSession(null, null, {
+      alwaysMatch: {
+        platformName: 'iOS',
+        'appium:deviceName': 'Dumb',
+        'appium:foo': 1
+      }
+    }).should.eventually.be.rejectedWith(/'foo' must be of type string/);
+
+    try {
+      await d.createSession(null, null, {
+        alwaysMatch: {
+          platformName: 'iOS',
+          'appium:deviceName': 'Dumb',
+          'appium:foo': undefined
+        }
+      });
+    } finally {
+      await d.deleteSession();
+    }
+
+    try {
+      await d.createSession(null, null, {
+        alwaysMatch: {
+          platformName: 'iOS',
+          'appium:deviceName': 'Dumb',
+          'appium:foo': ''
+        }
+      });
+    } finally {
+      await d.deleteSession();
+    }
+  });
+  it('should still validate null/undefined/empty caps whose presence is required', async function () {
+    d.desiredCapConstraints = {
+      foo: {
+        presence: true
+      }
+    };
+    await d.createSession(null, null, {
+      alwaysMatch: {
+        platformName: 'iOS',
+        'appium:deviceName': 'Dumb',
+        'appium:foo': null
+      }
+    }).should.eventually.be.rejectedWith(/blank/);
+    await d.createSession(null, {
+      alwaysMatch: {
+        platformName: 'iOS',
+        'appium:deviceName': 'Dumb',
+        'appium:foo': ''
+      }
+    }).should.eventually.be.rejectedWith(/blank/);
+    await d.createSession({
+      firstMatch: [{
+        platformName: 'iOS',
+        'appium:deviceName': 'Dumb',
+        'appium:foo': {}
+      }]
+    }).should.eventually.be.rejectedWith(/blank/);
+    await d.createSession({
+      alwaysMatch: {
+        platformName: 'iOS',
+        'appium:deviceName': 'Dumb',
+        'appium:foo': []
+      }
+    }).should.eventually.be.rejectedWith(/blank/);
+    await d.createSession({
+      alwaysMatch: {
+        platformName: 'iOS',
+        'appium:deviceName': 'Dumb',
+        'appium:foo': '  '
+      }
+    }).should.eventually.be.rejectedWith(/blank/);
+  });
+  describe('w3c', function () {
+    it('should accept w3c capabilities', async function () {
+      const [sessionId, caps] = await d.createSession(null, null, {
+        alwaysMatch: {
+          platformName: 'iOS',
+          'appium:deviceName': 'Delorean'
+        },
+        firstMatch: [{}]
+      });
+
+      try {
+        sessionId.should.exist;
+        caps.should.eql({
+          platformName: 'iOS',
+          deviceName: 'Delorean'
+        });
+      } finally {
+        await d.deleteSession();
+      }
+    });
+    it('should raise an error if w3c capabilities is not a plain JSON object', async function () {
+      const testValues = [true, 'string', [], 100];
+      await _bluebird.default.map(testValues, val => d.createSession(null, null, val).should.eventually.be.rejectedWith(_lib.errors.SessionNotCreatedError));
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../test/unit/basedriver/capability.spec.js"],"names":["describe","d","sandbox","beforeEach","BaseDriver","spy","log","logger","afterEach","restore","it","createSession","firstMatch","should","eventually","be","rejectedWith","errors","SessionNotCreatedError","alwaysMatch","platformName","fulfilled","desiredCapConstraints","necessary","presence","proper","isString","inclusion","timeout","warn","have","been","called","sessions","getSessions","capabilities","noReset","eql","not","language","newCommandTimeout","a","deprecated","deleteSession","undefined","foo","sessionId","caps","exist","deviceName","testValues","B","map","val"],"mappings":"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","sourcesContent":["// @ts-check\n\nimport B from 'bluebird';\nimport { default as BaseDriver, errors } from '../../../lib';\nimport logger from '../../../lib/basedriver/logger';\nimport { createSandbox } from 'sinon';\n\ndescribe('Desired Capabilities', function () {\n  let d;\n  let sandbox;\n\n  beforeEach(function () {\n    d = new BaseDriver();\n    sandbox = createSandbox();\n    sandbox.spy(d.log, 'warn');\n    sandbox.spy(logger, 'warn');\n  });\n\n  afterEach(function () {\n    sandbox.restore();\n  });\n\n  it('should require platformName and deviceName', async function () {\n    await d.createSession({\n      firstMatch: [{}]\n    }).should.eventually.be.rejectedWith(errors.SessionNotCreatedError, /platformName/);\n  });\n\n\n  it('should require platformName', async function () {\n    await d.createSession({\n      alwaysMatch: {\n        'appium:deviceName': 'Delorean'\n      }\n    }).should.eventually.be.rejectedWith(errors.SessionNotCreatedError, /platformName/);\n  });\n\n  it('should not care about cap order', async function () {\n    await d.createSession(null, null, {\n      alwaysMatch: {\n        'appium:deviceName': 'Delorean',\n        platformName: 'iOS'\n      }\n    }).should.eventually.be.fulfilled;\n  });\n\n  it('should check required caps which are added to driver', async function () {\n    d.desiredCapConstraints = {\n      necessary: {\n        presence: true\n      },\n      proper: {\n        presence: true,\n        isString: true,\n        inclusion: ['Delorean', 'Reventon']\n      }\n    };\n\n    await d.createSession(null, null, {\n      alwaysMatch: {\n        'platformName': 'iOS',\n        'appium:deviceName': 'Delorean'\n      }\n    }).should.eventually.be.rejectedWith(errors.SessionNotCreatedError, /necessary.*proper/);\n  });\n\n  it('should check added required caps in addition to base', async function () {\n    d.desiredCapConstraints = {\n      necessary: {\n        presence: true\n      },\n      proper: {\n        presence: true,\n        isString: true,\n        inclusion: ['Delorean', 'Reventon']\n      }\n    };\n\n    await d.createSession(null, null, {\n      alwaysMatch: {\n        'appium:necessary': 'yup'\n      }\n    }).should.eventually.be.rejectedWith(errors.SessionNotCreatedError, /platformName/);\n  });\n\n  it('should accept extra capabilities', async function () {\n    await d.createSession(null, null, {\n      alwaysMatch: {\n        'platformName': 'iOS',\n        'appium:deviceName': 'Delorean',\n        'appium:extra': 'cheese',\n        'appium:hold the': 'sauce'\n      }\n    }).should.eventually.be.fulfilled;\n  });\n\n  it('should log the use of extra caps', async function () {\n    this.timeout(500);\n\n    await d.createSession(null, null, {\n      alwaysMatch: {\n        'platformName': 'iOS',\n        'appium:deviceName': 'Delorean',\n        'appium:extra': 'cheese',\n        'appium:hold the': 'sauce'\n      }\n    });\n\n    d.log.warn.should.have.been.called;\n  });\n\n  it('should be sensitive to the case of caps', async function () {\n    await d.createSession(null, null, {\n      alwaysMatch: {\n        'platformname': 'iOS',\n        'appium:deviceName': 'Delorean'\n      }\n    }).should.eventually.be.rejectedWith(errors.SessionNotCreatedError, /platformName/);\n  });\n\n  describe('boolean capabilities', function () {\n    it('should allow a string \"false\"', async function () {\n      await d.createSession(null, null, {\n        alwaysMatch: {\n          'platformName': 'iOS',\n          'appium:deviceName': 'Delorean',\n          'appium:noReset': 'false'\n        }\n      });\n      d.log.warn.should.have.been.called;\n\n      let sessions = await d.getSessions();\n      sessions[0].capabilities.noReset.should.eql(false);\n    });\n\n    it('should allow a string \"true\"', async function () {\n      await d.createSession(null, null, {\n        alwaysMatch: {\n          'platformName': 'iOS',\n          'appium:deviceName': 'Delorean',\n          'appium:noReset': 'true'\n        }\n      });\n      d.log.warn.should.have.been.called;\n\n      let sessions = await d.getSessions();\n      sessions[0].capabilities.noReset.should.eql(true);\n    });\n\n    it('should allow a string \"true\" in string capabilities', async function () {\n      await d.createSession(null, null, {\n        alwaysMatch: {\n          'platformName': 'iOS',\n          'appium:deviceName': 'Delorean',\n          'appium:language': 'true'\n        }\n      });\n      d.log.warn.should.not.have.been.called;\n\n      let sessions = await d.getSessions();\n      sessions[0].capabilities.language.should.eql('true');\n    });\n  });\n\n  describe('number capabilities', function () {\n    it('should allow a string \"1\"', async function () {\n      await d.createSession(null, null, {\n        alwaysMatch: {\n          'platformName': 'iOS',\n          'appium:deviceName': 'Delorean',\n          'appium:newCommandTimeout': '1'\n        }\n      });\n      d.log.warn.should.have.been.called;\n\n      let sessions = await d.getSessions();\n      sessions[0].capabilities.newCommandTimeout.should.eql(1);\n    });\n\n    it('should allow a string \"1.1\"', async function () {\n      await d.createSession(null, null, {\n        alwaysMatch: {\n          'platformName': 'iOS',\n          'appium:deviceName': 'Delorean',\n          'appium:newCommandTimeout': '1.1'\n        }\n      });\n      d.log.warn.should.have.been.called;\n\n      let sessions = await d.getSessions();\n      sessions[0].capabilities.newCommandTimeout.should.eql(1.1);\n    });\n\n    it('should allow a string \"1\" in string capabilities', async function () {\n      await d.createSession(null, null, {\n        alwaysMatch: {\n          'platformName': 'iOS',\n          'appium:deviceName': 'Delorean',\n          'appium:language': '1'\n        }\n      });\n      d.log.warn.should.not.have.been.called;\n\n      let sessions = await d.getSessions();\n      sessions[0].capabilities.language.should.eql('1');\n    });\n  });\n\n  it ('should error if objects in caps', async function () {\n    await d.createSession(null, null, {\n      alwaysMatch: {\n        'platformName': {a: 'iOS'},\n        'appium:deviceName': 'Delorean'\n      }\n    }).should.eventually.be.rejectedWith(errors.SessionNotCreatedError, /platformName/i);\n  });\n\n  it('should check for deprecated caps', async function () {\n    this.timeout(500);\n\n    d.desiredCapConstraints = {\n      'lynx-version': {\n        deprecated: true\n      }\n    };\n\n    await d.createSession(null, null, {\n      alwaysMatch: {\n        'platformName': 'iOS',\n        'appium:deviceName': 'Delorean',\n        'appium:lynx-version': 5\n      }\n    });\n\n    logger.warn.should.have.been.called;\n  });\n\n  it('should not warn if deprecated=false', async function () {\n    this.timeout(500);\n\n    d.desiredCapConstraints = {\n      'lynx-version': {\n        deprecated: false\n      }\n    };\n\n    await d.createSession(null, null, {\n      alwaysMatch: {\n        'platformName': 'iOS',\n        'appium:deviceName': 'Delorean',\n        'appium:lynx-version': 5\n      }\n    });\n\n    d.log.warn.should.not.have.been.called;\n  });\n\n  it('should not validate against null/undefined caps', async function () {\n    d.desiredCapConstraints = {\n      'foo': {\n        isString: true\n      }\n    };\n\n    try {\n      await d.createSession(null, null, {\n        alwaysMatch: {\n          platformName: 'iOS',\n          'appium:deviceName': 'Dumb',\n          'appium:foo': null\n        }\n      });\n    } finally {\n      await d.deleteSession();\n    }\n\n    await d.createSession(null, null, {\n      alwaysMatch: {\n        platformName: 'iOS',\n        'appium:deviceName': 'Dumb',\n        'appium:foo': 1\n      }\n    }).should.eventually.be.rejectedWith(/'foo' must be of type string/);\n\n    try {\n      await d.createSession(null, null, {\n        alwaysMatch: {\n          platformName: 'iOS',\n          'appium:deviceName': 'Dumb',\n          'appium:foo': undefined\n        }\n      });\n    } finally {\n      await d.deleteSession();\n    }\n\n    try {\n      await d.createSession(null, null, {\n        alwaysMatch: {\n          platformName: 'iOS',\n          'appium:deviceName': 'Dumb',\n          'appium:foo': ''\n        }\n      });\n    } finally {\n      await d.deleteSession();\n    }\n  });\n\n  it('should still validate null/undefined/empty caps whose presence is required', async function () {\n    d.desiredCapConstraints = {\n      foo: {\n        presence: true\n      },\n    };\n\n    await d.createSession(null, null, {\n      alwaysMatch: {\n        platformName: 'iOS',\n        'appium:deviceName': 'Dumb',\n        'appium:foo': null\n      }\n    }).should.eventually.be.rejectedWith(/blank/);\n\n    await d.createSession(null, {\n      alwaysMatch: {\n        platformName: 'iOS',\n        'appium:deviceName': 'Dumb',\n        'appium:foo': ''\n      }\n    }).should.eventually.be.rejectedWith(/blank/);\n\n    await d.createSession({\n      firstMatch: [{\n        platformName: 'iOS',\n        'appium:deviceName': 'Dumb',\n        'appium:foo': {}\n      }]\n    }).should.eventually.be.rejectedWith(/blank/);\n\n    await d.createSession({\n      alwaysMatch: {\n        platformName: 'iOS',\n        'appium:deviceName': 'Dumb',\n        'appium:foo': []\n      }\n    }).should.eventually.be.rejectedWith(/blank/);\n\n    await d.createSession({\n      alwaysMatch: {\n        platformName: 'iOS',\n        'appium:deviceName': 'Dumb',\n        'appium:foo': '  '\n      }\n    }).should.eventually.be.rejectedWith(/blank/);\n  });\n\n  describe('w3c', function () {\n    it('should accept w3c capabilities', async function () {\n      const [sessionId, caps] = await d.createSession(null, null, {\n        alwaysMatch: {\n          platformName: 'iOS',\n          'appium:deviceName': 'Delorean'\n        }, firstMatch: [{}],\n      });\n      try {\n        sessionId.should.exist;\n        caps.should.eql({\n          platformName: 'iOS',\n          deviceName: 'Delorean',\n        });\n      } finally {\n        await d.deleteSession();\n      }\n    });\n\n    it('should raise an error if w3c capabilities is not a plain JSON object', async function () {\n      const testValues = [true, 'string', [], 100];\n      // this loop runs in parallel, and does not guarantee all assertions will be made\n      await B.map(testValues, (val) => d.createSession(null, null, val).should.eventually.be.rejectedWith(errors.SessionNotCreatedError));\n    });\n  });\n});\n"]}

package/build/test/unit/basedriver/commands/event.spec.js

@@ -0,0 +1,110 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _lib = require("../../../../lib");
+
+describe('logging custom events', function () {
+  it('should allow logging of events', async function () {
+    const d = new _lib.BaseDriver();
+
+    d._eventHistory.should.eql({
+      commands: []
+    });
+
+    await d.logCustomEvent('myorg', 'myevent');
+
+    _lodash.default.keys(d._eventHistory).should.eql(['commands', 'myorg:myevent']);
+  });
+  it('should get all events including custom ones', async function () {
+    const d = new _lib.BaseDriver();
+
+    d._eventHistory.should.eql({
+      commands: []
+    });
+
+    d.logEvent('appiumEvent');
+    await d.logCustomEvent('myorg', 'myevent');
+    const events = await d.getLogEvents();
+
+    _lodash.default.keys(events).should.eql(['commands', 'appiumEvent', 'myorg:myevent']);
+  });
+});
+describe('#getLogEvents', function () {
+  it('should allow to get all events', async function () {
+    const d = new _lib.BaseDriver();
+
+    d._eventHistory.should.eql({
+      commands: []
+    });
+
+    d._eventHistory.testCommand = ['1', '2', '3'];
+    await d.getLogEvents().should.eql({
+      commands: [],
+      testCommand: ['1', '2', '3']
+    });
+  });
+  it('should filter with testCommand', async function () {
+    const d = new _lib.BaseDriver();
+
+    d._eventHistory.should.eql({
+      commands: []
+    });
+
+    d._eventHistory.testCommand = ['1', '2', '3'];
+    await d.getLogEvents('testCommand').should.eql({
+      testCommand: ['1', '2', '3']
+    });
+  });
+  it('should not filter with wrong but can be a part of the event name', async function () {
+    const d = new _lib.BaseDriver();
+
+    d._eventHistory.should.eql({
+      commands: []
+    });
+
+    d._eventHistory.testCommand = ['1', '2', '3'];
+    await d.getLogEvents('testCommandDummy').should.eql({});
+  });
+  it('should filter with multiple event keys', async function () {
+    const d = new _lib.BaseDriver();
+
+    d._eventHistory.should.eql({
+      commands: []
+    });
+
+    d._eventHistory.testCommand = ['1', '2', '3'];
+    d._eventHistory.testCommand2 = ['4', '5'];
+    await d.getLogEvents(['testCommand', 'testCommand2']).should.eql({
+      testCommand: ['1', '2', '3'],
+      testCommand2: ['4', '5']
+    });
+  });
+  it('should filter with custom events', async function () {
+    const d = new _lib.BaseDriver();
+
+    d._eventHistory.should.eql({
+      commands: []
+    });
+
+    d._eventHistory['custom:appiumEvent'] = ['1', '2', '3'];
+    await d.getLogEvents(['custom:appiumEvent']).should.eql({
+      'custom:appiumEvent': ['1', '2', '3']
+    });
+  });
+  it('should not filter with no existed event name', async function () {
+    const d = new _lib.BaseDriver();
+
+    d._eventHistory.should.eql({
+      commands: []
+    });
+
+    d._eventHistory.testCommand = ['1', '2', '3'];
+    await d.getLogEvents(['noEventName']).should.eql({});
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../../test/unit/basedriver/commands/event.spec.js"],"names":["describe","it","d","BaseDriver","_eventHistory","should","eql","commands","logCustomEvent","_","keys","logEvent","events","getLogEvents","testCommand","testCommand2"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport { BaseDriver } from '../../../../lib';\n\n\n\ndescribe('logging custom events', function () {\n  it('should allow logging of events', async function () {\n    const d = new BaseDriver();\n    d._eventHistory.should.eql({commands: []});\n    await d.logCustomEvent('myorg', 'myevent');\n    _.keys(d._eventHistory).should.eql(['commands', 'myorg:myevent']);\n  });\n  it('should get all events including custom ones', async function () {\n    const d = new BaseDriver();\n    d._eventHistory.should.eql({commands: []});\n    d.logEvent('appiumEvent');\n    await d.logCustomEvent('myorg', 'myevent');\n    const events = await d.getLogEvents();\n    _.keys(events).should.eql(['commands', 'appiumEvent', 'myorg:myevent']);\n  });\n});\n\ndescribe('#getLogEvents', function () {\n  it('should allow to get all events', async function () {\n    const d = new BaseDriver();\n    d._eventHistory.should.eql({commands: []});\n    d._eventHistory.testCommand = ['1', '2', '3'];\n    await d.getLogEvents().should.eql({\n      commands: [], testCommand: ['1', '2', '3']\n    });\n  });\n\n  it('should filter with testCommand', async function () {\n    const d = new BaseDriver();\n    d._eventHistory.should.eql({commands: []});\n    d._eventHistory.testCommand = ['1', '2', '3'];\n    await d.getLogEvents('testCommand').should.eql({\n      testCommand: ['1', '2', '3']\n    });\n  });\n\n  it('should not filter with wrong but can be a part of the event name', async function () {\n    const d = new BaseDriver();\n    d._eventHistory.should.eql({commands: []});\n    d._eventHistory.testCommand = ['1', '2', '3'];\n    await d.getLogEvents('testCommandDummy').should.eql({});\n  });\n\n  it('should filter with multiple event keys', async function () {\n    const d = new BaseDriver();\n    d._eventHistory.should.eql({commands: []});\n    d._eventHistory.testCommand = ['1', '2', '3'];\n    d._eventHistory.testCommand2 = ['4', '5'];\n    await d.getLogEvents(['testCommand', 'testCommand2']).should.eql({\n      testCommand: ['1', '2', '3'], testCommand2: ['4', '5']\n    });\n  });\n\n  it('should filter with custom events', async function () {\n    const d = new BaseDriver();\n    d._eventHistory.should.eql({commands: []});\n    d._eventHistory['custom:appiumEvent'] = ['1', '2', '3'];\n    await d.getLogEvents(['custom:appiumEvent']).should.eql({\n      'custom:appiumEvent': ['1', '2', '3']\n    });\n  });\n\n  it('should not filter with no existed event name', async function () {\n    const d = new BaseDriver();\n    d._eventHistory.should.eql({commands: []});\n    d._eventHistory.testCommand = ['1', '2', '3'];\n    await d.getLogEvents(['noEventName']).should.eql({});\n  });\n});\n"]}

package/build/test/unit/basedriver/commands/log.spec.js

@@ -0,0 +1,85 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _log = _interopRequireDefault(require("../../../../lib/basedriver/commands/log"));
+
+var _sinon = require("sinon");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+const expect = chai.expect;
+const FIRST_LOGS = ['first', 'logs'];
+const SECOND_LOGS = ['second', 'logs'];
+const SUPPORTED_LOG_TYPES = {
+  one: {
+    description: 'First logs',
+    getter: () => _lodash.default.clone(FIRST_LOGS)
+  },
+  two: {
+    description: 'Seconds logs',
+    getter: () => _lodash.default.clone(SECOND_LOGS)
+  }
+};
+describe('log commands -', function () {
+  let sandbox;
+  beforeEach(function () {
+    sandbox = (0, _sinon.createSandbox)();
+    _log.default.supportedLogTypes = {};
+    _log.default.log = {
+      debug: _lodash.default.noop
+    };
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('getLogTypes', function () {
+    it('should return empty array when no supported log types', async function () {
+      (await _log.default.getLogTypes()).should.eql([]);
+    });
+    it('should return keys to log type object', async function () {
+      _log.default.supportedLogTypes = SUPPORTED_LOG_TYPES;
+      (await _log.default.getLogTypes()).should.eql(['one', 'two']);
+    });
+  });
+  describe('getLog', function () {
+    beforeEach(function () {
+      sandbox.spy(SUPPORTED_LOG_TYPES.one, 'getter');
+      sandbox.spy(SUPPORTED_LOG_TYPES.two, 'getter');
+    });
+    afterEach(function () {
+      SUPPORTED_LOG_TYPES.one.getter.restore();
+      SUPPORTED_LOG_TYPES.two.getter.restore();
+    });
+    it('should throw error if log type not supported', async function () {
+      await _log.default.getLog('one').should.eventually.be.rejected;
+      SUPPORTED_LOG_TYPES.one.getter.called.should.be.false;
+      SUPPORTED_LOG_TYPES.two.getter.called.should.be.false;
+    });
+    it('should throw an error with available log types if log type not supported', async function () {
+      _log.default.supportedLogTypes = SUPPORTED_LOG_TYPES;
+      let err;
+
+      try {
+        await _log.default.getLog('three');
+      } catch (_err) {
+        err = _err;
+      }
+
+      expect(err).to.exist;
+      err.message.should.eql(`Unsupported log type 'three'. Supported types: {"one":"First logs","two":"Seconds logs"}`);
+      SUPPORTED_LOG_TYPES.one.getter.called.should.be.false;
+      SUPPORTED_LOG_TYPES.two.getter.called.should.be.false;
+    });
+    it('should call getter on appropriate log when found', async function () {
+      _log.default.supportedLogTypes = SUPPORTED_LOG_TYPES;
+      let logs = await _log.default.getLog('one');
+      logs.should.eql(FIRST_LOGS);
+      SUPPORTED_LOG_TYPES.one.getter.called.should.be.true;
+      SUPPORTED_LOG_TYPES.two.getter.called.should.be.false;
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/test/unit/basedriver/driver.spec.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _lib = _interopRequireDefault(require("../../../lib"));
+
+var _basedriver = require("../../basedriver");
+
+(0, _basedriver.baseDriverUnitTests)(_lib.default, {
+  platformName: 'iOS',
+  'appium:deviceName': 'Delorean'
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Rlc3QvdW5pdC9iYXNlZHJpdmVyL2RyaXZlci5zcGVjLmpzIl0sIm5hbWVzIjpbIkJhc2VEcml2ZXIiLCJwbGF0Zm9ybU5hbWUiXSwibWFwcGluZ3MiOiI7Ozs7OztBQUVBOztBQUNBOztBQUVBLHFDQUFvQkEsWUFBcEIsRUFBZ0M7QUFDOUJDLEVBQUFBLFlBQVksRUFBRSxLQURnQjtBQUU5Qix1QkFBcUI7QUFGUyxDQUFoQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIHRyYW5zcGlsZTptb2NoYVxuXG5pbXBvcnQgQmFzZURyaXZlciBmcm9tICcuLi8uLi8uLi9saWInO1xuaW1wb3J0IHsgYmFzZURyaXZlclVuaXRUZXN0cyB9IGZyb20gJy4uLy4uL2Jhc2Vkcml2ZXInO1xuXG5iYXNlRHJpdmVyVW5pdFRlc3RzKEJhc2VEcml2ZXIsIHtcbiAgcGxhdGZvcm1OYW1lOiAnaU9TJyxcbiAgJ2FwcGl1bTpkZXZpY2VOYW1lJzogJ0RlbG9yZWFuJ1xufSk7XG4iXX0=