@appium/base-driver 8.3.0 → 8.3.1

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

@@ -0,0 +1,672 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _capabilities = require("../../../lib/basedriver/capabilities");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _desiredCaps = require("../../../lib/basedriver/desired-caps");
+
+var _capabilities2 = require("../../../lib/helpers/capabilities");
+
+describe('caps', function () {
+  describe('#validateCaps', function () {
+    it('returns invalid argument error if "capability" is not a JSON object (1)', function () {
+      for (let arg of [undefined, null, 1, true, 'string']) {
+        (function () {
+          (0, _capabilities.validateCaps)(arg);
+        }).should.throw(/must be a JSON object/);
+      }
+    });
+    it('returns result {} by default if caps is empty object and no constraints provided (2)', function () {
+      (0, _capabilities.validateCaps)({}).should.deep.equal({});
+    });
+    describe('throws errors if constraints are not met', function () {
+      it('returns invalid argument error if "present" constraint not met on property', function () {
+        (() => (0, _capabilities.validateCaps)({}, {
+          foo: {
+            presence: true
+          }
+        })).should.throw(/'foo' can't be blank/);
+      });
+      it('returns the capability that was passed in if "skipPresenceConstraint" is false', function () {
+        (0, _capabilities.validateCaps)({}, {
+          foo: {
+            presence: true
+          }
+        }, {
+          skipPresenceConstraint: true
+        }).should.deep.equal({});
+      });
+      it('returns invalid argument error if "isString" constraint not met on property', function () {
+        (() => (0, _capabilities.validateCaps)({
+          foo: 1
+        }, {
+          foo: {
+            isString: true
+          }
+        })).should.throw(/'foo' must be of type string/);
+      });
+      it('returns invalid argument error if "isNumber" constraint not met on property', function () {
+        (() => (0, _capabilities.validateCaps)({
+          foo: 'bar'
+        }, {
+          foo: {
+            isNumber: true
+          }
+        })).should.throw(/'foo' must be of type number/);
+      });
+      it('returns invalid argument error if "isBoolean" constraint not met on property', function () {
+        (() => (0, _capabilities.validateCaps)({
+          foo: 'bar'
+        }, {
+          foo: {
+            isBoolean: true
+          }
+        })).should.throw(/'foo' must be of type boolean/);
+      });
+      it('returns invalid argument error if "inclusion" constraint not met on property', function () {
+        (() => (0, _capabilities.validateCaps)({
+          foo: '3'
+        }, {
+          foo: {
+            inclusionCaseInsensitive: ['1', '2']
+          }
+        })).should.throw(/'foo' 3 not part of 1,2/);
+      });
+      it('returns invalid argument error if "inclusionCaseInsensitive" constraint not met on property', function () {
+        (() => (0, _capabilities.validateCaps)({
+          foo: 'a'
+        }, {
+          foo: {
+            inclusion: ['A', 'B', 'C']
+          }
+        })).should.throw(/'foo' a is not included in the list/);
+      });
+    });
+    it('should not throw errors if constraints are met', function () {
+      let caps = {
+        number: 1,
+        string: 'string',
+        present: 'present',
+        extra: 'extra'
+      };
+      let constraints = {
+        number: {
+          isNumber: true
+        },
+        string: {
+          isString: true
+        },
+        present: {
+          presence: true
+        },
+        notPresent: {
+          presence: false
+        }
+      };
+      (0, _capabilities.validateCaps)(caps, constraints).should.deep.equal(caps);
+    });
+  });
+  describe('#mergeCaps', function () {
+    it('returns a result that is {} by default (1)', function () {
+      (0, _capabilities.mergeCaps)().should.deep.equal({});
+    });
+    it('returns a result that matches primary by default (2, 3)', function () {
+      (0, _capabilities.mergeCaps)({
+        hello: 'world'
+      }).should.deep.equal({
+        hello: 'world'
+      });
+    });
+    it('returns invalid argument error if primary and secondary have matching properties (4)', function () {
+      (() => (0, _capabilities.mergeCaps)({
+        hello: 'world'
+      }, {
+        hello: 'whirl'
+      })).should.throw(/property 'hello' should not exist on both primary [\w\W]* and secondary [\w\W]*/);
+    });
+    it('returns a result with keys from primary and secondary together', function () {
+      let primary = {
+        a: 'a',
+        b: 'b'
+      };
+      let secondary = {
+        c: 'c',
+        d: 'd'
+      };
+      (0, _capabilities.mergeCaps)(primary, secondary).should.deep.equal({
+        a: 'a',
+        b: 'b',
+        c: 'c',
+        d: 'd'
+      });
+    });
+  });
+  describe('#parseCaps', function () {
+    let caps;
+    beforeEach(function () {
+      caps = {};
+    });
+    it('should return invalid argument if no caps object provided', function () {
+      (() => (0, _capabilities.parseCaps)()).should.throw(/must be a JSON object/);
+    });
+    it('sets "requiredCaps" to property named "alwaysMatch" (2)', function () {
+      caps.alwaysMatch = {
+        'appium:hello': 'world'
+      };
+      (0, _capabilities.parseCaps)(caps).requiredCaps.should.deep.equal(caps.alwaysMatch);
+    });
+    it('sets "requiredCaps" to empty JSON object if "alwaysMatch" is not an object (2.1)', function () {
+      (0, _capabilities.parseCaps)(caps).requiredCaps.should.deep.equal({});
+    });
+    it('returns invalid argument error if "requiredCaps" don\'t match "constraints" (2.2)', function () {
+      caps.alwaysMatch = {
+        'appium:foo': 1
+      };
+      (() => (0, _capabilities.parseCaps)(caps, {
+        foo: {
+          isString: true
+        }
+      })).should.throw(/'foo' must be of type string/);
+    });
+    it('sets "allFirstMatchCaps" to property named "firstMatch" (3)', function () {
+      (0, _capabilities.parseCaps)({}, [{}]).allFirstMatchCaps.should.deep.equal([{}]);
+    });
+    it('sets "allFirstMatchCaps" to [{}] if "firstMatch" is undefined (3.1)', function () {
+      (0, _capabilities.parseCaps)({}).allFirstMatchCaps.should.deep.equal([{}]);
+    });
+    it('returns invalid argument error if "firstMatch" is not an array and is not undefined (3.2)', function () {
+      for (let arg of [null, 1, true, 'string']) {
+        caps.firstMatch = arg;
+        (function () {
+          (0, _capabilities.parseCaps)(caps);
+        }).should.throw(/must be a JSON array or undefined/);
+      }
+    });
+    it('has "validatedFirstMatchCaps" property that is empty by default if no valid firstMatch caps were found (4)', function () {
+      (0, _capabilities.parseCaps)(caps, {
+        foo: {
+          presence: true
+        }
+      }).validatedFirstMatchCaps.should.deep.equal([]);
+    });
+    describe('returns a "validatedFirstMatchCaps" array (5)', function () {
+      it('that equals "firstMatch" if firstMatch is one empty object and there are no constraints', function () {
+        caps.firstMatch = [{}];
+        (0, _capabilities.parseCaps)(caps).validatedFirstMatchCaps.should.deep.equal(caps.firstMatch);
+      });
+      it('returns "null" matchedCaps if nothing matches', function () {
+        caps.firstMatch = [{}];
+        should.equal((0, _capabilities.parseCaps)(caps, {
+          foo: {
+            presence: true
+          }
+        }).matchedCaps, null);
+      });
+      it(`should return capabilities if presence constraint is matched in at least one of the 'firstMatch' capabilities objects`, function () {
+        caps.alwaysMatch = {
+          'appium:foo': 'bar'
+        };
+        caps.firstMatch = [{
+          'appium:hello': 'world'
+        }, {
+          'appium:goodbye': 'world'
+        }];
+        (0, _capabilities.parseCaps)(caps, {
+          goodbye: {
+            presence: true
+          }
+        }).matchedCaps.should.deep.equal({
+          foo: 'bar',
+          goodbye: 'world'
+        });
+      });
+      it(`throws invalid argument if presence constraint is not met on any capabilities`, function () {
+        caps.alwaysMatch = {
+          'appium:foo': 'bar'
+        };
+        caps.firstMatch = [{
+          'appium:hello': 'world'
+        }, {
+          'appium:goodbye': 'world'
+        }];
+        should.equal((0, _capabilities.parseCaps)(caps, {
+          someAttribute: {
+            presence: true
+          }
+        }).matchedCaps, null);
+      });
+      it('that equals firstMatch if firstMatch contains two objects that pass the provided constraints', function () {
+        caps.alwaysMatch = {
+          'appium:foo': 'bar'
+        };
+        caps.firstMatch = [{
+          'appium:foo': 'bar1'
+        }, {
+          'appium:foo': 'bar2'
+        }];
+        let constraints = {
+          foo: {
+            presence: true,
+            isString: true
+          }
+        };
+        (0, _capabilities.parseCaps)(caps, constraints).validatedFirstMatchCaps.should.deep.equal(caps.firstMatch);
+      });
+      it('returns no vendor prefix error if the firstMatch[2] does not have it because of no bject', function () {
+        caps.alwaysMatch = {};
+        caps.firstMatch = [{
+          'appium:foo': 'bar'
+        }, 'foo'];
+        (() => (0, _capabilities.parseCaps)(caps, {})).should.throw(/All non-standard capabilities should have a vendor prefix/);
+      });
+    });
+    describe('returns a matchedCaps object (6)', function () {
+      beforeEach(function () {
+        caps.alwaysMatch = {
+          'appium:hello': 'world'
+        };
+      });
+      it('which is same as alwaysMatch if firstMatch array is not provided', function () {
+        (0, _capabilities.parseCaps)(caps).matchedCaps.should.deep.equal({
+          hello: 'world'
+        });
+      });
+      it('merges caps together', function () {
+        caps.firstMatch = [{
+          'appium:foo': 'bar'
+        }];
+        (0, _capabilities.parseCaps)(caps).matchedCaps.should.deep.equal({
+          hello: 'world',
+          foo: 'bar'
+        });
+      });
+      it('with merged caps', function () {
+        caps.firstMatch = [{
+          'appium:hello': 'bar',
+          'appium:foo': 'foo'
+        }, {
+          'appium:foo': 'bar'
+        }];
+        (0, _capabilities.parseCaps)(caps).matchedCaps.should.deep.equal({
+          hello: 'world',
+          foo: 'bar'
+        });
+      });
+    });
+  });
+  describe('#processCaps', function () {
+    it('should return "alwaysMatch" if "firstMatch" and "constraints" were not provided', function () {
+      (0, _capabilities.processCapabilities)({}).should.deep.equal({});
+    });
+    it('should return merged caps', function () {
+      (0, _capabilities.processCapabilities)({
+        alwaysMatch: {
+          'appium:hello': 'world'
+        },
+        firstMatch: [{
+          'appium:foo': 'bar'
+        }]
+      }).should.deep.equal({
+        hello: 'world',
+        foo: 'bar'
+      });
+    });
+    it('should strip out the "appium:" prefix for non-standard capabilities', function () {
+      (0, _capabilities.processCapabilities)({
+        alwaysMatch: {
+          'appium:hello': 'world'
+        },
+        firstMatch: [{
+          'appium:foo': 'bar'
+        }]
+      }).should.deep.equal({
+        hello: 'world',
+        foo: 'bar'
+      });
+    });
+    it('should still accept prefixed caps even if they are standard capabilities (https://www.w3.org/TR/webdriver/#dfn-table-of-standard-capabilities)', function () {
+      (0, _capabilities.processCapabilities)({
+        alwaysMatch: {
+          'appium:platformName': 'Whatevz'
+        },
+        firstMatch: [{
+          'appium:browserName': 'Anything'
+        }]
+      }).should.deep.equal({
+        platformName: 'Whatevz',
+        browserName: 'Anything'
+      });
+    });
+    it('should prefer standard caps that are non-prefixed to prefixed', function () {
+      (0, _capabilities.processCapabilities)({
+        alwaysMatch: {
+          'appium:platformName': 'Foo',
+          'platformName': 'Bar'
+        },
+        firstMatch: [{
+          'appium:browserName': 'FOO',
+          'browserName': 'BAR'
+        }]
+      }).should.deep.equal({
+        platformName: 'Bar',
+        browserName: 'BAR'
+      });
+    });
+    it('should throw exception if duplicates in alwaysMatch and firstMatch', function () {
+      (() => (0, _capabilities.processCapabilities)({
+        alwaysMatch: {
+          'platformName': 'Fake',
+          'appium:fakeCap': 'foobar'
+        },
+        firstMatch: [{
+          'appium:platformName': 'bar'
+        }]
+      })).should.throw(/should not exist on both primary/);
+    });
+    it('should not throw an exception if presence constraint is not met on a firstMatch capability', function () {
+      const caps = (0, _capabilities.processCapabilities)({
+        alwaysMatch: {
+          'platformName': 'Fake',
+          'appium:fakeCap': 'foobar'
+        },
+        firstMatch: [{
+          'appium:foo': 'bar'
+        }]
+      }, {
+        platformName: {
+          presence: true
+        },
+        fakeCap: {
+          presence: true
+        }
+      });
+      caps.platformName.should.equal('Fake');
+      caps.fakeCap.should.equal('foobar');
+      caps.foo.should.equal('bar');
+    });
+    it('should throw an exception if no matching caps were found', function () {
+      (() => (0, _capabilities.processCapabilities)({
+        alwaysMatch: {
+          'platformName': 'Fake',
+          'appium:fakeCap': 'foobar'
+        },
+        firstMatch: [{
+          'appium:foo': 'bar'
+        }]
+      }, {
+        platformName: {
+          presence: true
+        },
+        fakeCap: {
+          presence: true
+        },
+        missingCap: {
+          presence: true
+        }
+      })).should.throw(/'missingCap' can't be blank/);
+    });
+    describe('validate Appium constraints', function () {
+      const constraints = { ..._desiredCaps.desiredCapabilityConstraints
+      };
+      const expectedMatchingCaps = {
+        'platformName': 'Fake',
+        'automationName': 'Fake',
+        'deviceName': 'Fake'
+      };
+      let matchingCaps;
+      let caps;
+      beforeEach(function () {
+        matchingCaps = {
+          'platformName': 'Fake',
+          'appium:automationName': 'Fake',
+          'appium:deviceName': 'Fake'
+        };
+      });
+      it('should validate when alwaysMatch has the proper caps', function () {
+        caps = {
+          alwaysMatch: matchingCaps,
+          firstMatch: [{}]
+        };
+        (0, _capabilities.processCapabilities)(caps, constraints).should.deep.equal(expectedMatchingCaps);
+      });
+      it('should validate when firstMatch[0] has the proper caps', function () {
+        caps = {
+          alwaysMatch: {},
+          firstMatch: [matchingCaps]
+        };
+        (0, _capabilities.processCapabilities)(caps, constraints).should.deep.equal(expectedMatchingCaps);
+      });
+      it('should validate when alwaysMatch and firstMatch[0] have the proper caps when merged together', function () {
+        caps = {
+          alwaysMatch: _lodash.default.omit(matchingCaps, ['appium:deviceName']),
+          firstMatch: [{
+            'appium:deviceName': 'Fake'
+          }]
+        };
+        (0, _capabilities.processCapabilities)(caps, constraints).should.deep.equal(expectedMatchingCaps);
+      });
+      it('should validate when automationName is omitted', function () {
+        caps = {
+          alwaysMatch: _lodash.default.omit(matchingCaps, ['appium:automationName'])
+        };
+        (0, _capabilities.processCapabilities)(caps, constraints).should.deep.equal(_lodash.default.omit(expectedMatchingCaps, 'automationName'));
+      });
+      it('should pass if first element in "firstMatch" does validate and second element does not', function () {
+        caps = {
+          alwaysMatch: {},
+          firstMatch: [matchingCaps, {
+            'appium:badCaps': 'badCaps'
+          }]
+        };
+        (0, _capabilities.processCapabilities)(caps, constraints).should.deep.equal(expectedMatchingCaps);
+      });
+      it('should pass if first element in "firstMatch" does not validate and second element does', function () {
+        caps = {
+          alwaysMatch: {},
+          firstMatch: [{
+            'appium:badCaps': 'badCaps'
+          }, matchingCaps]
+        };
+        (0, _capabilities.processCapabilities)(caps, constraints).should.deep.equal(expectedMatchingCaps);
+      });
+      it('should fail when bad parameters are passed in more than one firstMatch capability', function () {
+        caps = {
+          alwaysMatch: {},
+          firstMatch: [{
+            'appium:bad': 'params'
+          }, {
+            'appium:more': 'bad-params'
+          }]
+        };
+        (() => (0, _capabilities.processCapabilities)(caps, constraints)).should.throw(/Could not find matching capabilities/);
+      });
+    });
+  });
+  describe('.findNonPrefixedCaps', function () {
+    it('should find alwaysMatch caps with no prefix', function () {
+      (0, _capabilities.findNonPrefixedCaps)({
+        alwaysMatch: {
+          'non-standard': 'dummy'
+        }
+      }).should.eql(['non-standard']);
+    });
+    it('should not find a standard cap in alwaysMatch', function () {
+      (0, _capabilities.findNonPrefixedCaps)({
+        alwaysMatch: {
+          'platformName': 'Any'
+        }
+      }).should.eql([]);
+    });
+    it('should find firstMatch caps with no prefix', function () {
+      (0, _capabilities.findNonPrefixedCaps)({
+        alwaysMatch: {},
+        firstMatch: [{
+          'non-standard': 'dummy'
+        }]
+      }).should.eql(['non-standard']);
+    });
+    it('should not find a standard cap in prefix', function () {
+      (0, _capabilities.findNonPrefixedCaps)({
+        alwaysMatch: {},
+        firstMatch: [{
+          'platformName': 'Any'
+        }]
+      }).should.eql([]);
+    });
+    it('should find firstMatch caps in second item of firstMatch array', function () {
+      (0, _capabilities.findNonPrefixedCaps)({
+        alwaysMatch: {},
+        firstMatch: [{}, {
+          'non-standard': 'dummy'
+        }]
+      }).should.eql(['non-standard']);
+    });
+    it('should remove duplicates from alwaysMatch and firstMatch', function () {
+      (0, _capabilities.findNonPrefixedCaps)({
+        alwaysMatch: {
+          'non-standard': 'something'
+        },
+        firstMatch: [{
+          'non-standard': 'dummy'
+        }]
+      }).should.eql(['non-standard']);
+    });
+    it('should remove duplicates from firstMatch', function () {
+      (0, _capabilities.findNonPrefixedCaps)({
+        firstMatch: [{
+          'non-standard': 'dummy'
+        }, {
+          'non-standard': 'dummy 2'
+        }]
+      }).should.eql(['non-standard']);
+    });
+    it('should remove duplicates and keep standard capabilities', function () {
+      const alwaysMatch = {
+        platformName: 'Fake',
+        nonStandardOne: 'non-standard',
+        nonStandardTwo: 'non-standard'
+      };
+      const firstMatch = [{
+        nonStandardThree: 'non-standard',
+        nonStandardFour: 'non-standard',
+        browserName: 'FakeBrowser'
+      }, {
+        nonStandardThree: 'non-standard',
+        nonStandardFour: 'non-standard',
+        nonStandardFive: 'non-standard',
+        browserVersion: 'whateva'
+      }];
+      (0, _capabilities.findNonPrefixedCaps)({
+        alwaysMatch,
+        firstMatch
+      }).should.eql(['nonStandardOne', 'nonStandardTwo', 'nonStandardThree', 'nonStandardFour', 'nonStandardFive']);
+    });
+  });
+  describe('#promoteAppiumOptions', function () {
+    const appiumCaps = {
+      'appium:platformVersion': '14.4',
+      'appium:deviceName': 'iPhone 11',
+      'appium:app': '/foo/bar.app.zip',
+      'appium:automationName': 'XCUITest'
+    };
+    const nonAppiumCaps = {
+      platformName: 'iOS'
+    };
+
+    const appiumUnprefixedCaps = _lodash.default.clone(appiumCaps);
+
+    (0, _capabilities.stripAppiumPrefixes)(appiumUnprefixedCaps);
+    const simpleCaps = { ...nonAppiumCaps,
+      ...appiumUnprefixedCaps
+    };
+    it('should do nothing to caps that dont include the options', function () {
+      (0, _capabilities.promoteAppiumOptions)(simpleCaps).should.eql(simpleCaps);
+    });
+    it('should promote options', function () {
+      const caps = { ...nonAppiumCaps,
+        [_capabilities.APPIUM_OPTS_CAP]: { ...appiumUnprefixedCaps
+        }
+      };
+      (0, _capabilities.promoteAppiumOptions)(caps).should.eql(simpleCaps);
+    });
+    it('should get rid of prefixes if caps inside options are prefixed', function () {
+      const caps = { ...nonAppiumCaps,
+        [_capabilities.APPIUM_OPTS_CAP]: { ...appiumCaps
+        }
+      };
+      (0, _capabilities.promoteAppiumOptions)(caps).should.eql(simpleCaps);
+    });
+    it('should preserve non-appium vendor prefixes', function () {
+      const googCaps = {
+        'goog:chromeOptions': {
+          foo: 'bar'
+        }
+      };
+      const caps = { ...nonAppiumCaps,
+        [_capabilities.APPIUM_OPTS_CAP]: { ...appiumCaps,
+          ...googCaps
+        }
+      };
+      (0, _capabilities.promoteAppiumOptions)(caps).should.eql({ ...simpleCaps,
+        ...googCaps
+      });
+    });
+    it('should overwrite caps found on the top level', function () {
+      const caps = { ...nonAppiumCaps,
+        foo: 'bar',
+        [_capabilities.APPIUM_OPTS_CAP]: { ...appiumCaps,
+          foo: 'baz'
+        }
+      };
+      (0, _capabilities.promoteAppiumOptions)(caps).should.eql({ ...simpleCaps,
+        foo: 'baz'
+      });
+    });
+  });
+  describe('#isW3cCaps', function () {
+    it('should drop invalid W3C capabilities', function () {
+      for (const invalidCaps of [null, undefined, [], {}, {
+        firstMatch: null
+      }, {
+        firtMatch: [{}]
+      }, {
+        alwaysMatch: null
+      }, {
+        firstMatch: [{}],
+        alwaysMatch: null
+      }, {
+        firstMatch: [],
+        alwaysMatch: {}
+      }, {
+        firstMatch: []
+      }, {
+        firstMatch: {}
+      }, {
+        alwaysMatch: []
+      }]) {
+        (0, _capabilities2.isW3cCaps)(invalidCaps).should.be.false;
+      }
+    });
+    it('should accept valid W3C capabilities', function () {
+      for (const validCaps of [{
+        firstMatch: [{}]
+      }, {
+        firstMatch: [{}],
+        alaysMatch: {}
+      }, {
+        firtMatch: [{}],
+        alwaysMatch: {}
+      }, {
+        alwaysMatch: {}
+      }]) {
+        (0, _capabilities2.isW3cCaps)(validCaps).should.be.true;
+      }
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../test/unit/basedriver/capabilities.spec.js"],"names":["describe","it","arg","undefined","should","throw","deep","equal","foo","presence","skipPresenceConstraint","isString","isNumber","isBoolean","inclusionCaseInsensitive","inclusion","caps","number","string","present","extra","constraints","notPresent","hello","primary","a","b","secondary","c","d","beforeEach","alwaysMatch","requiredCaps","allFirstMatchCaps","firstMatch","validatedFirstMatchCaps","matchedCaps","goodbye","someAttribute","platformName","browserName","fakeCap","missingCap","desiredCapabilityConstraints","expectedMatchingCaps","matchingCaps","_","omit","eql","nonStandardOne","nonStandardTwo","nonStandardThree","nonStandardFour","nonStandardFive","browserVersion","appiumCaps","nonAppiumCaps","appiumUnprefixedCaps","clone","simpleCaps","APPIUM_OPTS_CAP","googCaps","invalidCaps","firtMatch","be","false","validCaps","alaysMatch","true"],"mappings":"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","sourcesContent":["import {\n  parseCaps, validateCaps, mergeCaps, processCapabilities, findNonPrefixedCaps,\n  promoteAppiumOptions, APPIUM_OPTS_CAP, stripAppiumPrefixes\n} from '../../../lib/basedriver/capabilities';\nimport _ from 'lodash';\nimport { desiredCapabilityConstraints } from '../../../lib/basedriver/desired-caps';\nimport { isW3cCaps } from '../../../lib/helpers/capabilities';\n\n\ndescribe('caps', function () {\n\n  // Tests based on: https://www.w3.org/TR/webdriver/#dfn-validate-caps\n  describe('#validateCaps', function () {\n    it('returns invalid argument error if \"capability\" is not a JSON object (1)', function () {\n      for (let arg of [undefined, null, 1, true, 'string']) {\n        (function () { validateCaps(arg); }).should.throw(/must be a JSON object/);\n      }\n    });\n\n    it('returns result {} by default if caps is empty object and no constraints provided (2)', function () {\n      validateCaps({}).should.deep.equal({});\n    });\n\n    describe('throws errors if constraints are not met', function () {\n      it('returns invalid argument error if \"present\" constraint not met on property', function () {\n        (() => validateCaps({}, {foo: {presence: true}})).should.throw(/'foo' can't be blank/);\n      });\n\n      it('returns the capability that was passed in if \"skipPresenceConstraint\" is false', function () {\n        validateCaps({}, {foo: {presence: true}}, {skipPresenceConstraint: true}).should.deep.equal({});\n      });\n\n      it('returns invalid argument error if \"isString\" constraint not met on property', function () {\n        (() => validateCaps({foo: 1}, {foo: {isString: true}})).should.throw(/'foo' must be of type string/);\n      });\n\n      it('returns invalid argument error if \"isNumber\" constraint not met on property', function () {\n        (() => validateCaps({foo: 'bar'}, {foo: {isNumber: true}})).should.throw(/'foo' must be of type number/);\n      });\n\n      it('returns invalid argument error if \"isBoolean\" constraint not met on property', function () {\n        (() => validateCaps({foo: 'bar'}, {foo: {isBoolean: true}})).should.throw(/'foo' must be of type boolean/);\n      });\n\n      it('returns invalid argument error if \"inclusion\" constraint not met on property', function () {\n        (() => validateCaps({foo: '3'}, {foo: {inclusionCaseInsensitive: ['1', '2']}})).should.throw(/'foo' 3 not part of 1,2/);\n      });\n\n      it('returns invalid argument error if \"inclusionCaseInsensitive\" constraint not met on property', function () {\n        (() => validateCaps({foo: 'a'}, {foo: {inclusion: ['A', 'B', 'C']}})).should.throw(/'foo' a is not included in the list/);\n      });\n    });\n\n    it('should not throw errors if constraints are met', function () {\n      let caps = {\n        number: 1,\n        string: 'string',\n        present: 'present',\n        extra: 'extra',\n      };\n\n      let constraints = {\n        number: {isNumber: true},\n        string: {isString: true},\n        present: {presence: true},\n        notPresent: {presence: false},\n      };\n\n      validateCaps(caps, constraints).should.deep.equal(caps);\n    });\n  });\n\n  // Tests based on: https://www.w3.org/TR/webdriver/#dfn-merging-caps\n  describe('#mergeCaps', function () {\n    it('returns a result that is {} by default (1)', function () {\n      mergeCaps().should.deep.equal({});\n    });\n\n    it('returns a result that matches primary by default (2, 3)', function () {\n      mergeCaps({hello: 'world'}).should.deep.equal({hello: 'world'});\n    });\n\n    it('returns invalid argument error if primary and secondary have matching properties (4)', function () {\n      (() => mergeCaps({hello: 'world'}, {hello: 'whirl'})).should.throw(/property 'hello' should not exist on both primary [\\w\\W]* and secondary [\\w\\W]*/);\n    });\n\n    it('returns a result with keys from primary and secondary together', function () {\n      let primary = {\n        a: 'a',\n        b: 'b',\n      };\n      let secondary = {\n        c: 'c',\n        d: 'd',\n      };\n      mergeCaps(primary, secondary).should.deep.equal({\n        a: 'a', b: 'b', c: 'c', d: 'd',\n      });\n    });\n  });\n\n  // Tests based on: https://www.w3.org/TR/webdriver/#processing-capabilities\n  describe('#parseCaps', function () {\n    let caps;\n\n    beforeEach(function () {\n      caps = {};\n    });\n\n    it('should return invalid argument if no caps object provided', function () {\n      (() => parseCaps()).should.throw(/must be a JSON object/);\n    });\n\n    it('sets \"requiredCaps\" to property named \"alwaysMatch\" (2)', function () {\n      caps.alwaysMatch = {'appium:hello': 'world'};\n      parseCaps(caps).requiredCaps.should.deep.equal(caps.alwaysMatch);\n    });\n\n    it('sets \"requiredCaps\" to empty JSON object if \"alwaysMatch\" is not an object (2.1)', function () {\n      parseCaps(caps).requiredCaps.should.deep.equal({});\n    });\n\n    it('returns invalid argument error if \"requiredCaps\" don\\'t match \"constraints\" (2.2)', function () {\n      caps.alwaysMatch = {'appium:foo': 1};\n      (() => parseCaps(caps, {foo: {isString: true}})).should.throw(/'foo' must be of type string/);\n    });\n\n    it('sets \"allFirstMatchCaps\" to property named \"firstMatch\" (3)', function () {\n      parseCaps({}, [{}]).allFirstMatchCaps.should.deep.equal([{}]);\n    });\n\n    it('sets \"allFirstMatchCaps\" to [{}] if \"firstMatch\" is undefined (3.1)', function () {\n      parseCaps({}).allFirstMatchCaps.should.deep.equal([{}]);\n    });\n\n    it('returns invalid argument error if \"firstMatch\" is not an array and is not undefined (3.2)', function () {\n      for (let arg of [null, 1, true, 'string']) {\n        caps.firstMatch = arg;\n        (function () { parseCaps(caps); }).should.throw(/must be a JSON array or undefined/);\n      }\n    });\n\n    it('has \"validatedFirstMatchCaps\" property that is empty by default if no valid firstMatch caps were found (4)', function () {\n      parseCaps(caps, {foo: {presence: true}}).validatedFirstMatchCaps.should.deep.equal([]);\n    });\n\n    describe('returns a \"validatedFirstMatchCaps\" array (5)', function () {\n      it('that equals \"firstMatch\" if firstMatch is one empty object and there are no constraints', function () {\n        caps.firstMatch = [{}];\n        parseCaps(caps).validatedFirstMatchCaps.should.deep.equal(caps.firstMatch);\n      });\n\n      it('returns \"null\" matchedCaps if nothing matches', function () {\n        caps.firstMatch = [{}];\n        should.equal(parseCaps(caps, {foo: {presence: true}}).matchedCaps, null);\n      });\n\n      it(`should return capabilities if presence constraint is matched in at least one of the 'firstMatch' capabilities objects`, function () {\n        caps.alwaysMatch = {\n          'appium:foo': 'bar',\n        };\n        caps.firstMatch = [{\n          'appium:hello': 'world',\n        }, {\n          'appium:goodbye': 'world',\n        }];\n        parseCaps(caps, {goodbye: {presence: true}}).matchedCaps.should.deep.equal({\n          foo: 'bar',\n          goodbye: 'world',\n        });\n      });\n\n      it(`throws invalid argument if presence constraint is not met on any capabilities`, function () {\n        caps.alwaysMatch = {\n          'appium:foo': 'bar',\n        };\n        caps.firstMatch = [{\n          'appium:hello': 'world',\n        }, {\n          'appium:goodbye': 'world',\n        }];\n        should.equal(parseCaps(caps, {someAttribute: {presence: true}}).matchedCaps, null);\n      });\n\n      it('that equals firstMatch if firstMatch contains two objects that pass the provided constraints', function () {\n        caps.alwaysMatch = {\n          'appium:foo': 'bar'\n        };\n        caps.firstMatch = [\n          {'appium:foo': 'bar1'},\n          {'appium:foo': 'bar2'},\n        ];\n\n        let constraints = {\n          foo: {\n            presence: true,\n            isString: true,\n          }\n        };\n\n        parseCaps(caps, constraints).validatedFirstMatchCaps.should.deep.equal(caps.firstMatch);\n      });\n\n      it('returns no vendor prefix error if the firstMatch[2] does not have it because of no bject', function () {\n        caps.alwaysMatch = {};\n        caps.firstMatch = [{'appium:foo': 'bar'}, 'foo'];\n        (() => parseCaps(caps, {})).should.throw(/All non-standard capabilities should have a vendor prefix/);\n      });\n    });\n\n    describe('returns a matchedCaps object (6)', function () {\n      beforeEach(function () {\n        caps.alwaysMatch = {'appium:hello': 'world'};\n      });\n\n      it('which is same as alwaysMatch if firstMatch array is not provided', function () {\n        parseCaps(caps).matchedCaps.should.deep.equal({hello: 'world'});\n      });\n\n      it('merges caps together', function () {\n        caps.firstMatch = [{'appium:foo': 'bar'}];\n        parseCaps(caps).matchedCaps.should.deep.equal({hello: 'world', foo: 'bar'});\n      });\n\n      it('with merged caps', function () {\n        caps.firstMatch = [{'appium:hello': 'bar', 'appium:foo': 'foo'}, {'appium:foo': 'bar'}];\n        parseCaps(caps).matchedCaps.should.deep.equal({hello: 'world', foo: 'bar'});\n      });\n    });\n  });\n\n  describe('#processCaps', function () {\n    it('should return \"alwaysMatch\" if \"firstMatch\" and \"constraints\" were not provided', function () {\n      processCapabilities({}).should.deep.equal({});\n    });\n\n    it('should return merged caps', function () {\n      processCapabilities({\n        alwaysMatch: {'appium:hello': 'world'},\n        firstMatch: [{'appium:foo': 'bar'}]\n      }).should.deep.equal({hello: 'world', foo: 'bar'});\n    });\n\n    it('should strip out the \"appium:\" prefix for non-standard capabilities', function () {\n      processCapabilities({\n        alwaysMatch: {'appium:hello': 'world'},\n        firstMatch: [{'appium:foo': 'bar'}]\n      }).should.deep.equal({hello: 'world', foo: 'bar'});\n    });\n\n    it('should still accept prefixed caps even if they are standard capabilities (https://www.w3.org/TR/webdriver/#dfn-table-of-standard-capabilities)', function () {\n      processCapabilities({\n        alwaysMatch: {'appium:platformName': 'Whatevz'},\n        firstMatch: [{'appium:browserName': 'Anything'}],\n      }).should.deep.equal({platformName: 'Whatevz', browserName: 'Anything'});\n    });\n\n    it('should prefer standard caps that are non-prefixed to prefixed', function () {\n      processCapabilities({\n        alwaysMatch: {'appium:platformName': 'Foo', 'platformName': 'Bar'},\n        firstMatch: [{'appium:browserName': 'FOO', 'browserName': 'BAR'}],\n      }).should.deep.equal({platformName: 'Bar', browserName: 'BAR'});\n    });\n    it('should throw exception if duplicates in alwaysMatch and firstMatch', function () {\n      (() => processCapabilities({\n        alwaysMatch: {'platformName': 'Fake', 'appium:fakeCap': 'foobar'},\n        firstMatch: [{'appium:platformName': 'bar'}],\n      })).should.throw(/should not exist on both primary/);\n    });\n\n    it('should not throw an exception if presence constraint is not met on a firstMatch capability', function () {\n      const caps = processCapabilities({\n        alwaysMatch: {'platformName': 'Fake', 'appium:fakeCap': 'foobar'},\n        firstMatch: [{'appium:foo': 'bar'}],\n      }, {\n        platformName: {\n          presence: true,\n        },\n        fakeCap: {\n          presence: true\n        },\n      });\n\n      caps.platformName.should.equal('Fake');\n      caps.fakeCap.should.equal('foobar');\n      caps.foo.should.equal('bar');\n    });\n\n    it('should throw an exception if no matching caps were found', function () {\n      (() => processCapabilities({\n        alwaysMatch: {'platformName': 'Fake', 'appium:fakeCap': 'foobar'},\n        firstMatch: [{'appium:foo': 'bar'}],\n      }, {\n        platformName: {\n          presence: true,\n        },\n        fakeCap: {\n          presence: true\n        },\n        missingCap: {\n          presence: true,\n        },\n      })).should.throw(/'missingCap' can't be blank/);\n    });\n\n    describe('validate Appium constraints', function () {\n      const constraints = {...desiredCapabilityConstraints};\n      const expectedMatchingCaps = {'platformName': 'Fake', 'automationName': 'Fake', 'deviceName': 'Fake'};\n\n      let matchingCaps;\n      let caps;\n\n      beforeEach(function () {\n        matchingCaps = {\n          'platformName': 'Fake',\n          'appium:automationName': 'Fake',\n          'appium:deviceName': 'Fake'\n        };\n      });\n\n      it('should validate when alwaysMatch has the proper caps', function () {\n        caps = {\n          alwaysMatch: matchingCaps,\n          firstMatch: [{}],\n        };\n        processCapabilities(caps, constraints).should.deep.equal(expectedMatchingCaps);\n      });\n\n\n      it('should validate when firstMatch[0] has the proper caps', function () {\n        caps = {\n          alwaysMatch: {},\n          firstMatch: [matchingCaps],\n        };\n        processCapabilities(caps, constraints).should.deep.equal(expectedMatchingCaps);\n      });\n\n      it('should validate when alwaysMatch and firstMatch[0] have the proper caps when merged together', function () {\n        caps = {\n          alwaysMatch: _.omit(matchingCaps, ['appium:deviceName']),\n          firstMatch: [{'appium:deviceName': 'Fake'}],\n        };\n        processCapabilities(caps, constraints).should.deep.equal(expectedMatchingCaps);\n      });\n\n      it('should validate when automationName is omitted', function () {\n        caps = {\n          alwaysMatch: _.omit(matchingCaps, ['appium:automationName']),\n        };\n        processCapabilities(caps, constraints).should.deep.equal(_.omit(expectedMatchingCaps, 'automationName'));\n      });\n\n      it('should pass if first element in \"firstMatch\" does validate and second element does not', function () {\n        caps = {\n          alwaysMatch: {},\n          firstMatch: [\n            matchingCaps,\n            {'appium:badCaps': 'badCaps'},\n          ],\n        };\n        processCapabilities(caps, constraints).should.deep.equal(expectedMatchingCaps);\n      });\n\n      it('should pass if first element in \"firstMatch\" does not validate and second element does', function () {\n        caps = {\n          alwaysMatch: {},\n          firstMatch: [\n            {'appium:badCaps': 'badCaps'},\n            matchingCaps,\n          ],\n        };\n        processCapabilities(caps, constraints).should.deep.equal(expectedMatchingCaps);\n      });\n\n      it('should fail when bad parameters are passed in more than one firstMatch capability', function () {\n        caps = {\n          alwaysMatch: {},\n          firstMatch: [{\n            'appium:bad': 'params',\n          }, {\n            'appium:more': 'bad-params',\n          }],\n        };\n        (() => processCapabilities(caps, constraints)).should.throw(/Could not find matching capabilities/);\n      });\n    });\n  });\n  describe('.findNonPrefixedCaps', function () {\n    it('should find alwaysMatch caps with no prefix', function () {\n      findNonPrefixedCaps({alwaysMatch: {\n        'non-standard': 'dummy',\n      }}).should.eql(['non-standard']);\n    });\n    it('should not find a standard cap in alwaysMatch', function () {\n      findNonPrefixedCaps({alwaysMatch: {\n        'platformName': 'Any',\n      }}).should.eql([]);\n    });\n    it('should find firstMatch caps with no prefix', function () {\n      findNonPrefixedCaps({alwaysMatch: {}, firstMatch: [{\n        'non-standard': 'dummy',\n      }]}).should.eql(['non-standard']);\n    });\n    it('should not find a standard cap in prefix', function () {\n      findNonPrefixedCaps({alwaysMatch: {}, firstMatch: [{\n        'platformName': 'Any',\n      }]}).should.eql([]);\n    });\n    it('should find firstMatch caps in second item of firstMatch array', function () {\n      findNonPrefixedCaps({alwaysMatch: {}, firstMatch: [{}, {\n        'non-standard': 'dummy',\n      }]}).should.eql(['non-standard']);\n    });\n    it('should remove duplicates from alwaysMatch and firstMatch', function () {\n      findNonPrefixedCaps({alwaysMatch: {\n        'non-standard': 'something',\n      }, firstMatch: [{\n        'non-standard': 'dummy',\n      }]}).should.eql(['non-standard']);\n    });\n    it('should remove duplicates from firstMatch', function () {\n      findNonPrefixedCaps({firstMatch: [{\n        'non-standard': 'dummy',\n      }, {\n        'non-standard': 'dummy 2',\n      }]}).should.eql(['non-standard']);\n    });\n    it('should remove duplicates and keep standard capabilities', function () {\n      const alwaysMatch = {\n        platformName: 'Fake',\n        nonStandardOne: 'non-standard',\n        nonStandardTwo: 'non-standard',\n      };\n      const firstMatch = [\n        {nonStandardThree: 'non-standard', nonStandardFour: 'non-standard', browserName: 'FakeBrowser'},\n        {nonStandardThree: 'non-standard', nonStandardFour: 'non-standard', nonStandardFive: 'non-standard', browserVersion: 'whateva'},\n      ];\n      findNonPrefixedCaps({alwaysMatch, firstMatch}).should.eql(['nonStandardOne', 'nonStandardTwo', 'nonStandardThree', 'nonStandardFour', 'nonStandardFive']);\n    });\n  });\n\n  describe('#promoteAppiumOptions', function () {\n    const appiumCaps = {\n      'appium:platformVersion': '14.4',\n      'appium:deviceName': 'iPhone 11',\n      'appium:app': '/foo/bar.app.zip',\n      'appium:automationName': 'XCUITest',\n    };\n    const nonAppiumCaps = {\n      platformName: 'iOS',\n    };\n    const appiumUnprefixedCaps = _.clone(appiumCaps);\n    stripAppiumPrefixes(appiumUnprefixedCaps);\n    const simpleCaps = {\n      ...nonAppiumCaps,\n      ...appiumUnprefixedCaps,\n    };\n    it('should do nothing to caps that dont include the options', function () {\n      promoteAppiumOptions(simpleCaps).should.eql(simpleCaps);\n    });\n    it('should promote options', function () {\n      const caps = {\n        ...nonAppiumCaps,\n        [APPIUM_OPTS_CAP]: {\n          ...appiumUnprefixedCaps,\n        }\n      };\n      promoteAppiumOptions(caps).should.eql(simpleCaps);\n    });\n    it('should get rid of prefixes if caps inside options are prefixed', function () {\n      const caps = {\n        ...nonAppiumCaps,\n        [APPIUM_OPTS_CAP]: {\n          ...appiumCaps,\n        }\n      };\n      promoteAppiumOptions(caps).should.eql(simpleCaps);\n    });\n    it('should preserve non-appium vendor prefixes', function () {\n      const googCaps = {'goog:chromeOptions': {foo: 'bar'}};\n      const caps = {\n        ...nonAppiumCaps,\n        [APPIUM_OPTS_CAP]: {\n          ...appiumCaps,\n          ...googCaps,\n        },\n      };\n      promoteAppiumOptions(caps).should.eql({\n        ...simpleCaps,\n        ...googCaps,\n      });\n    });\n    it('should overwrite caps found on the top level', function () {\n      const caps = {\n        ...nonAppiumCaps,\n        foo: 'bar',\n        [APPIUM_OPTS_CAP]: {\n          ...appiumCaps,\n          foo: 'baz',\n        }\n      };\n      promoteAppiumOptions(caps).should.eql({\n        ...simpleCaps,\n        foo: 'baz',\n      });\n    });\n  });\n\n  describe('#isW3cCaps', function () {\n    it('should drop invalid W3C capabilities', function () {\n      for (const invalidCaps of [\n        null, undefined, [], {},\n        {firstMatch: null},\n        {firtMatch: [{}]},\n        {alwaysMatch: null},\n        {firstMatch: [{}], alwaysMatch: null},\n        {firstMatch: [], alwaysMatch: {}},\n        {firstMatch: []},\n        {firstMatch: {}},\n        {alwaysMatch: []},\n      ]) {\n        isW3cCaps(invalidCaps).should.be.false;\n      }\n    });\n\n    it('should accept valid W3C capabilities', function () {\n      for (const validCaps of [\n        {firstMatch: [{}]},\n        {firstMatch: [{}], alaysMatch: {}},\n        {firtMatch: [{}], alwaysMatch: {}},\n        {alwaysMatch: {}},\n      ]) {\n        isW3cCaps(validCaps).should.be.true;\n      }\n    });\n  });\n});\n"]}