@appium/base-driver 8.2.4 → 8.4.0

package/lib/protocol/sessions-cache.js

@@ -1,74 +0,0 @@
-import LRU from 'lru-cache';
-import { logger } from '@appium/support';
-import { PROTOCOLS } from '../constants';
-
-
-const GENERIC_PROTOCOL = 'GENERIC';
-const mjsonwpLog = logger.getLogger('MJSONWP');
-const w3cLog = logger.getLogger('W3C');
-const genericProtocolLog = logger.getLogger(GENERIC_PROTOCOL);
-
-
-class SessionsCache {
-  constructor (max) {
-    this._cache = new LRU({ max });
-  }
-
-  getLogger (sessionId, protocol) {
-    if (sessionId) {
-      if (this._cache.has(sessionId)) {
-        const value = this._cache.get(sessionId);
-        if (value.logger) {
-          return value.logger;
-        }
-        protocol = protocol || value.protocol;
-      }
-      // Always create a new logger instance for ids
-      // that are not in the current sessions list,
-      // so we can still see such ids as prefixes
-      return logger.getLogger(`${protocol || GENERIC_PROTOCOL} ` +
-        `(${sessionId.substring(0, Math.min(sessionId.length, 8))})`);
-    }
-
-    // Fall back to protocol name-only logger if session id is unknown
-    switch (protocol) {
-      case PROTOCOLS.W3C:
-        return w3cLog;
-      case PROTOCOLS.MJSONWP:
-        return mjsonwpLog;
-      default:
-        return genericProtocolLog;
-    }
-  }
-
-  getProtocol (sessionId) {
-    return (this._cache.get(sessionId) || {}).protocol;
-  }
-
-  putSession (sessionId, value) {
-    if (sessionId && value) {
-      this._cache.set(sessionId, {
-        protocol: value,
-        // We don't want to cache the logger instance for each random session id in the cache
-        // in order to save memory. Instead we only cache loggers for valid ids that
-        // are returned by `createSession` call and reset them after `deleteSession` is called
-        logger: this.getLogger(sessionId, value),
-      });
-    }
-    return value;
-  }
-
-  resetLogger (sessionId) {
-    if (this._cache.has(sessionId)) {
-      this._cache.get(sessionId).logger = null;
-    }
-  }
-}
-
-// This cache is useful when a session gets terminated
-// and removed from the sessions list in the umbrella driver,
-// but the client still tries to send a command to this session id.
-// So we know how to properly wrap the error message for it
-const SESSIONS_CACHE = new SessionsCache(100);
-
-export default SESSIONS_CACHE;

package/test/basedriver/capabilities-specs.js

@@ -1,505 +0,0 @@
-import { parseCaps, validateCaps, mergeCaps, processCapabilities, findNonPrefixedCaps,
-         promoteAppiumOptions, APPIUM_OPTS_CAP, stripAppiumPrefixes } from '../../lib/basedriver/capabilities';
-import _ from 'lodash';
-import { desiredCapabilityConstraints } from '../../lib/basedriver/desired-caps';
-
-
-describe('caps', function () {
-
-  // Tests based on: https://www.w3.org/TR/webdriver/#dfn-validate-caps
-  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 () { 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 () {
-      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 () {
-        (() => validateCaps({}, {foo: {presence: true}})).should.throw(/'foo' can't be blank/);
-      });
-
-      it('returns the capability that was passed in if "skipPresenceConstraint" is false', function () {
-        validateCaps({}, {foo: {presence: true}}, {skipPresenceConstraint: true}).should.deep.equal({});
-      });
-
-      it('returns invalid argument error if "isString" constraint not met on property', function () {
-        (() => 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 () {
-        (() => 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 () {
-        (() => 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 () {
-        (() => 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 () {
-        (() => 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},
-      };
-
-      validateCaps(caps, constraints).should.deep.equal(caps);
-    });
-  });
-
-  // Tests based on: https://www.w3.org/TR/webdriver/#dfn-merging-caps
-  describe('#mergeCaps', function () {
-    it('returns a result that is {} by default (1)', function () {
-      mergeCaps().should.deep.equal({});
-    });
-
-    it('returns a result that matches primary by default (2, 3)', function () {
-      mergeCaps({hello: 'world'}).should.deep.equal({hello: 'world'});
-    });
-
-    it('returns invalid argument error if primary and secondary have matching properties (4)', function () {
-      (() => 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',
-      };
-      mergeCaps(primary, secondary).should.deep.equal({
-        a: 'a', b: 'b', c: 'c', d: 'd',
-      });
-    });
-  });
-
-  // Tests based on: https://www.w3.org/TR/webdriver/#processing-capabilities
-  describe('#parseCaps', function () {
-    let caps;
-
-    beforeEach(function () {
-      caps = {};
-    });
-
-    it('should return invalid argument if no caps object provided', function () {
-      (() => parseCaps()).should.throw(/must be a JSON object/);
-    });
-
-    it('sets "requiredCaps" to property named "alwaysMatch" (2)', function () {
-      caps.alwaysMatch = {'appium:hello': 'world'};
-      parseCaps(caps).requiredCaps.should.deep.equal(caps.alwaysMatch);
-    });
-
-    it('sets "requiredCaps" to empty JSON object if "alwaysMatch" is not an object (2.1)', function () {
-      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};
-      (() => parseCaps(caps, {foo: {isString: true}})).should.throw(/'foo' must be of type string/);
-    });
-
-    it('sets "allFirstMatchCaps" to property named "firstMatch" (3)', function () {
-      parseCaps({}, [{}]).allFirstMatchCaps.should.deep.equal([{}]);
-    });
-
-    it('sets "allFirstMatchCaps" to [{}] if "firstMatch" is undefined (3.1)', function () {
-      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 () { 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 () {
-      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 = [{}];
-        parseCaps(caps).validatedFirstMatchCaps.should.deep.equal(caps.firstMatch);
-      });
-
-      it('returns "null" matchedCaps if nothing matches', function () {
-        caps.firstMatch = [{}];
-        should.equal(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',
-        }];
-        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(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,
-          }
-        };
-
-        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'];
-        (() => 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 () {
-        parseCaps(caps).matchedCaps.should.deep.equal({hello: 'world'});
-      });
-
-      it('merges caps together', function () {
-        caps.firstMatch = [{'appium:foo': 'bar'}];
-        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'}];
-        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 () {
-      processCapabilities({}).should.deep.equal({});
-    });
-
-    it('should return merged caps', function () {
-      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 () {
-      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 () {
-      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 () {
-      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 () {
-      (() => 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 = 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 () {
-      (() => 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 = {...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: [{}],
-        };
-        processCapabilities(caps, constraints).should.deep.equal(expectedMatchingCaps);
-      });
-
-
-      it('should validate when firstMatch[0] has the proper caps', function () {
-        caps = {
-          alwaysMatch: {},
-          firstMatch: [matchingCaps],
-        };
-        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: _.omit(matchingCaps, ['appium:deviceName']),
-          firstMatch: [{'appium:deviceName': 'Fake'}],
-        };
-        processCapabilities(caps, constraints).should.deep.equal(expectedMatchingCaps);
-      });
-
-      it('should validate when automationName is omitted', function () {
-        caps = {
-          alwaysMatch: _.omit(matchingCaps, ['appium:automationName']),
-        };
-        processCapabilities(caps, constraints).should.deep.equal(_.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'},
-          ],
-        };
-        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,
-          ],
-        };
-        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',
-          }],
-        };
-        (() => processCapabilities(caps, constraints)).should.throw(/Could not find matching capabilities/);
-      });
-    });
-  });
-  describe('.findNonPrefixedCaps', function () {
-    it('should find alwaysMatch caps with no prefix', function () {
-      findNonPrefixedCaps({alwaysMatch: {
-        'non-standard': 'dummy',
-      }}).should.eql(['non-standard']);
-    });
-    it('should not find a standard cap in alwaysMatch', function () {
-      findNonPrefixedCaps({alwaysMatch: {
-        'platformName': 'Any',
-      }}).should.eql([]);
-    });
-    it('should find firstMatch caps with no prefix', function () {
-      findNonPrefixedCaps({alwaysMatch: {}, firstMatch: [{
-        'non-standard': 'dummy',
-      }]}).should.eql(['non-standard']);
-    });
-    it('should not find a standard cap in prefix', function () {
-      findNonPrefixedCaps({alwaysMatch: {}, firstMatch: [{
-        'platformName': 'Any',
-      }]}).should.eql([]);
-    });
-    it('should find firstMatch caps in second item of firstMatch array', function () {
-      findNonPrefixedCaps({alwaysMatch: {}, firstMatch: [{}, {
-        'non-standard': 'dummy',
-      }]}).should.eql(['non-standard']);
-    });
-    it('should remove duplicates from alwaysMatch and firstMatch', function () {
-      findNonPrefixedCaps({alwaysMatch: {
-        'non-standard': 'something',
-      }, firstMatch: [{
-        'non-standard': 'dummy',
-      }]}).should.eql(['non-standard']);
-    });
-    it('should remove duplicates from firstMatch', function () {
-      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'},
-      ];
-      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 = _.clone(appiumCaps);
-    stripAppiumPrefixes(appiumUnprefixedCaps);
-    const simpleCaps = {
-      ...nonAppiumCaps,
-      ...appiumUnprefixedCaps,
-    };
-    it('should do nothing to caps that dont include the options', function () {
-      promoteAppiumOptions(simpleCaps).should.eql(simpleCaps);
-    });
-    it('should promote options', function () {
-      const caps = {
-        ...nonAppiumCaps,
-        [APPIUM_OPTS_CAP]: {
-          ...appiumUnprefixedCaps,
-        }
-      };
-      promoteAppiumOptions(caps).should.eql(simpleCaps);
-    });
-    it('should get rid of prefixes if caps inside options are prefixed', function () {
-      const caps = {
-        ...nonAppiumCaps,
-        [APPIUM_OPTS_CAP]: {
-          ...appiumCaps,
-        }
-      };
-      promoteAppiumOptions(caps).should.eql(simpleCaps);
-    });
-    it('should preserve non-appium vendor prefixes', function () {
-      const googCaps = {'goog:chromeOptions': {foo: 'bar'}};
-      const caps = {
-        ...nonAppiumCaps,
-        [APPIUM_OPTS_CAP]: {
-          ...appiumCaps,
-          ...googCaps,
-        },
-      };
-      promoteAppiumOptions(caps).should.eql({
-        ...simpleCaps,
-        ...googCaps,
-      });
-    });
-    it('should overwrite caps found on the top level', function () {
-      const caps = {
-        ...nonAppiumCaps,
-        foo: 'bar',
-        [APPIUM_OPTS_CAP]: {
-          ...appiumCaps,
-          foo: 'baz',
-        }
-      };
-      promoteAppiumOptions(caps).should.eql({
-        ...simpleCaps,
-        foo: 'baz',
-      });
-    });
-  });
-});