@appium/base-driver 8.3.0 → 8.4.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":";;;;;;AAAA;;AACA;;AAIAA,QAAQ,CAAC,uBAAD,EAA0B,YAAY;AAC5CC,EAAAA,EAAE,CAAC,gCAAD,EAAmC,kBAAkB;AACrD,UAAMC,CAAC,GAAG,IAAIC,eAAJ,EAAV;;AACAD,IAAAA,CAAC,CAACE,aAAF,CAAgBC,MAAhB,CAAuBC,GAAvB,CAA2B;AAACC,MAAAA,QAAQ,EAAE;AAAX,KAA3B;;AACA,UAAML,CAAC,CAACM,cAAF,CAAiB,OAAjB,EAA0B,SAA1B,CAAN;;AACAC,oBAAEC,IAAF,CAAOR,CAAC,CAACE,aAAT,EAAwBC,MAAxB,CAA+BC,GAA/B,CAAmC,CAAC,UAAD,EAAa,eAAb,CAAnC;AACD,GALC,CAAF;AAMAL,EAAAA,EAAE,CAAC,6CAAD,EAAgD,kBAAkB;AAClE,UAAMC,CAAC,GAAG,IAAIC,eAAJ,EAAV;;AACAD,IAAAA,CAAC,CAACE,aAAF,CAAgBC,MAAhB,CAAuBC,GAAvB,CAA2B;AAACC,MAAAA,QAAQ,EAAE;AAAX,KAA3B;;AACAL,IAAAA,CAAC,CAACS,QAAF,CAAW,aAAX;AACA,UAAMT,CAAC,CAACM,cAAF,CAAiB,OAAjB,EAA0B,SAA1B,CAAN;AACA,UAAMI,MAAM,GAAG,MAAMV,CAAC,CAACW,YAAF,EAArB;;AACAJ,oBAAEC,IAAF,CAAOE,MAAP,EAAeP,MAAf,CAAsBC,GAAtB,CAA0B,CAAC,UAAD,EAAa,aAAb,EAA4B,eAA5B,CAA1B;AACD,GAPC,CAAF;AAQD,CAfO,CAAR;AAiBAN,QAAQ,CAAC,eAAD,EAAkB,YAAY;AACpCC,EAAAA,EAAE,CAAC,gCAAD,EAAmC,kBAAkB;AACrD,UAAMC,CAAC,GAAG,IAAIC,eAAJ,EAAV;;AACAD,IAAAA,CAAC,CAACE,aAAF,CAAgBC,MAAhB,CAAuBC,GAAvB,CAA2B;AAACC,MAAAA,QAAQ,EAAE;AAAX,KAA3B;;AACAL,IAAAA,CAAC,CAACE,aAAF,CAAgBU,WAAhB,GAA8B,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,CAA9B;AACA,KAAC,MAAMZ,CAAC,CAACW,YAAF,EAAP,EAAyBR,MAAzB,CAAgCC,GAAhC,CAAoC;AAClCC,MAAAA,QAAQ,EAAE,EADwB;AACpBO,MAAAA,WAAW,EAAE,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX;AADO,KAApC;AAGD,GAPC,CAAF;AASAb,EAAAA,EAAE,CAAC,gCAAD,EAAmC,kBAAkB;AACrD,UAAMC,CAAC,GAAG,IAAIC,eAAJ,EAAV;;AACAD,IAAAA,CAAC,CAACE,aAAF,CAAgBC,MAAhB,CAAuBC,GAAvB,CAA2B;AAACC,MAAAA,QAAQ,EAAE;AAAX,KAA3B;;AACAL,IAAAA,CAAC,CAACE,aAAF,CAAgBU,WAAhB,GAA8B,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,CAA9B;AACA,KAAC,MAAMZ,CAAC,CAACW,YAAF,CAAe,aAAf,CAAP,EAAsCR,MAAtC,CAA6CC,GAA7C,CAAiD;AAC/CQ,MAAAA,WAAW,EAAE,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX;AADkC,KAAjD;AAGD,GAPC,CAAF;AASAb,EAAAA,EAAE,CAAC,kEAAD,EAAqE,kBAAkB;AACvF,UAAMC,CAAC,GAAG,IAAIC,eAAJ,EAAV;;AACAD,IAAAA,CAAC,CAACE,aAAF,CAAgBC,MAAhB,CAAuBC,GAAvB,CAA2B;AAACC,MAAAA,QAAQ,EAAE;AAAX,KAA3B;;AACAL,IAAAA,CAAC,CAACE,aAAF,CAAgBU,WAAhB,GAA8B,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,CAA9B;AACA,KAAC,MAAMZ,CAAC,CAACW,YAAF,CAAe,kBAAf,CAAP,EAA2CR,MAA3C,CAAkDC,GAAlD,CAAsD,EAAtD;AACD,GALC,CAAF;AAOAL,EAAAA,EAAE,CAAC,wCAAD,EAA2C,kBAAkB;AAC7D,UAAMC,CAAC,GAAG,IAAIC,eAAJ,EAAV;;AACAD,IAAAA,CAAC,CAACE,aAAF,CAAgBC,MAAhB,CAAuBC,GAAvB,CAA2B;AAACC,MAAAA,QAAQ,EAAE;AAAX,KAA3B;;AACAL,IAAAA,CAAC,CAACE,aAAF,CAAgBU,WAAhB,GAA8B,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,CAA9B;AACAZ,IAAAA,CAAC,CAACE,aAAF,CAAgBW,YAAhB,GAA+B,CAAC,GAAD,EAAM,GAAN,CAA/B;AACA,KAAC,MAAMb,CAAC,CAACW,YAAF,CAAe,CAAC,aAAD,EAAgB,cAAhB,CAAf,CAAP,EAAwDR,MAAxD,CAA+DC,GAA/D,CAAmE;AACjEQ,MAAAA,WAAW,EAAE,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,CADoD;AACnCC,MAAAA,YAAY,EAAE,CAAC,GAAD,EAAM,GAAN;AADqB,KAAnE;AAGD,GARC,CAAF;AAUAd,EAAAA,EAAE,CAAC,kCAAD,EAAqC,kBAAkB;AACvD,UAAMC,CAAC,GAAG,IAAIC,eAAJ,EAAV;;AACAD,IAAAA,CAAC,CAACE,aAAF,CAAgBC,MAAhB,CAAuBC,GAAvB,CAA2B;AAACC,MAAAA,QAAQ,EAAE;AAAX,KAA3B;;AACAL,IAAAA,CAAC,CAACE,aAAF,CAAgB,oBAAhB,IAAwC,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,CAAxC;AACA,KAAC,MAAMF,CAAC,CAACW,YAAF,CAAe,CAAC,oBAAD,CAAf,CAAP,EAA+CR,MAA/C,CAAsDC,GAAtD,CAA0D;AACxD,4BAAsB,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX;AADkC,KAA1D;AAGD,GAPC,CAAF;AASAL,EAAAA,EAAE,CAAC,8CAAD,EAAiD,kBAAkB;AACnE,UAAMC,CAAC,GAAG,IAAIC,eAAJ,EAAV;;AACAD,IAAAA,CAAC,CAACE,aAAF,CAAgBC,MAAhB,CAAuBC,GAAvB,CAA2B;AAACC,MAAAA,QAAQ,EAAE;AAAX,KAA3B;;AACAL,IAAAA,CAAC,CAACE,aAAF,CAAgBU,WAAhB,GAA8B,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,CAA9B;AACA,KAAC,MAAMZ,CAAC,CAACW,YAAF,CAAe,CAAC,aAAD,CAAf,CAAP,EAAwCR,MAAxC,CAA+CC,GAA/C,CAAmD,EAAnD;AACD,GALC,CAAF;AAMD,CAnDO,CAAR","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,92 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _log = 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;
+  let LogCommands;
+  let logCommands;
+  beforeEach(function () {
+    sandbox = (0, _sinon.createSandbox)();
+    LogCommands = (0, _log.LogMixin)(class {
+      get log() {
+        return this._log;
+      }
+
+    });
+    logCommands = new LogCommands();
+    logCommands.supportedLogTypes = {};
+    logCommands._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 logCommands.getLogTypes()).should.eql([]);
+    });
+    it('should return keys to log type object', async function () {
+      logCommands.supportedLogTypes = SUPPORTED_LOG_TYPES;
+      (await logCommands.getLogTypes()).should.eql(['one', 'two']);
+    });
+  });
+  describe('getLog', function () {
+    let one;
+    let two;
+    beforeEach(function () {
+      one = sandbox.spy(SUPPORTED_LOG_TYPES.one, 'getter');
+      two = sandbox.spy(SUPPORTED_LOG_TYPES.two, 'getter');
+    });
+    it('should throw error if log type not supported', async function () {
+      await logCommands.getLog('one').should.eventually.be.rejected;
+      one.called.should.be.false;
+      two.called.should.be.false;
+    });
+    it('should throw an error with available log types if log type not supported', async function () {
+      logCommands.supportedLogTypes = SUPPORTED_LOG_TYPES;
+      let err;
+
+      try {
+        await logCommands.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"}`);
+      one.called.should.be.false;
+      two.called.should.be.false;
+    });
+    it('should call getter on appropriate log when found', async function () {
+      logCommands.supportedLogTypes = SUPPORTED_LOG_TYPES;
+      let logs = await logCommands.getLog('one');
+      logs.should.eql(FIRST_LOGS);
+      one.called.should.be.true;
+      two.called.should.be.false;
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../../test/unit/basedriver/commands/log.spec.js"],"names":["expect","chai","FIRST_LOGS","SECOND_LOGS","SUPPORTED_LOG_TYPES","one","description","getter","_","clone","two","describe","sandbox","LogCommands","logCommands","beforeEach","log","_log","supportedLogTypes","debug","noop","afterEach","restore","it","getLogTypes","should","eql","spy","getLog","eventually","be","rejected","called","false","err","_err","to","exist","message","logs","true"],"mappings":"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","sourcesContent":["// @ts-check\nimport {LogMixin} from '../../../../lib/basedriver/commands/log';\nimport { createSandbox } from 'sinon';\nimport _ from 'lodash';\n\nconst expect = chai.expect;\n\nconst FIRST_LOGS = ['first', 'logs'];\nconst SECOND_LOGS = ['second', 'logs'];\nconst SUPPORTED_LOG_TYPES = {\n  one: {\n    description: 'First logs',\n    getter: () => _.clone(FIRST_LOGS),\n  },\n  two: {\n    description: 'Seconds logs',\n    getter: () => _.clone(SECOND_LOGS),\n  },\n};\n\ndescribe('log commands -', function () {\n  let sandbox;\n  /** @type {ReturnType<typeof LogMixin>} */\n  let LogCommands;\n\n  let logCommands;\n\n  beforeEach(function () {\n    sandbox = createSandbox();\n    // @ts-expect-error\n    LogCommands = LogMixin(class { get log () { return this._log; }});\n    logCommands = new LogCommands();\n    // reset the supported log types\n    logCommands.supportedLogTypes = {};\n    logCommands._log = /** @type {import('@appium/types').AppiumLogger} */({debug: _.noop});\n  });\n\n  afterEach(function () {\n    sandbox.restore();\n  });\n\n  describe('getLogTypes', function () {\n    it('should return empty array when no supported log types', async function () {\n      (await logCommands.getLogTypes()).should.eql([]);\n    });\n    it('should return keys to log type object', async function () {\n      logCommands.supportedLogTypes = SUPPORTED_LOG_TYPES;\n      (await logCommands.getLogTypes()).should.eql(['one', 'two']);\n    });\n  });\n  describe('getLog', function () {\n    /** @type {sinon.SinonSpiedMember<typeof SUPPORTED_LOG_TYPES.one.getter>} */\n    let one;\n    /** @type {sinon.SinonSpiedMember<typeof SUPPORTED_LOG_TYPES.two.getter>} */\n    let two;\n    beforeEach(function () {\n      one = sandbox.spy(SUPPORTED_LOG_TYPES.one, 'getter');\n      two = sandbox.spy(SUPPORTED_LOG_TYPES.two, 'getter');\n    });\n    it('should throw error if log type not supported', async function () {\n      await logCommands.getLog('one').should.eventually.be.rejected;\n      one.called.should.be.false;\n      two.called.should.be.false;\n    });\n    it('should throw an error with available log types if log type not supported', async function () {\n      logCommands.supportedLogTypes = SUPPORTED_LOG_TYPES;\n      let err;\n      try {\n        await logCommands.getLog('three');\n      } catch (_err) {\n        err = _err;\n      }\n      expect(err).to.exist;\n      err.message.should.eql(`Unsupported log type 'three'. Supported types: {\"one\":\"First logs\",\"two\":\"Seconds logs\"}`);\n      one.called.should.be.false;\n      two.called.should.be.false;\n    });\n    it('should call getter on appropriate log when found', async function () {\n      logCommands.supportedLogTypes = SUPPORTED_LOG_TYPES;\n      let logs = await logCommands.getLog('one');\n      logs.should.eql(FIRST_LOGS);\n      one.called.should.be.true;\n      two.called.should.be.false;\n    });\n  });\n});\n"]}

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=