@atlassian/atlassian-connect-js 5.3.190

package/spec/tests/utils/deprecate_spec.js

@@ -0,0 +1,22 @@
+import deprecateHost from '../../../src/host/deprecate';
+import Analytics from '../../../src/host/modules/analytics';
+
+const callback = () => {};
+callback._id = 'some-extension-id';
+callback._context = {
+  extension: {
+    addon_key: 'some-addon-key',
+    key: 'some-module-key',
+    options: jasmine.objectContaining({})
+  }
+};
+describe('host side deprecation', function () {
+  it('should deprecate function tracks analytics', function () {
+    const deprecateSpy = jasmine.createSpy('test function');
+    const analyticsSpy = spyOn(Analytics, 'trackDeprecatedMethodUsed');
+    const deprecated = deprecateHost(deprecateSpy, 'test function');
+    deprecated(callback);
+    expect(deprecateSpy).toHaveBeenCalled();
+    expect(analyticsSpy).toHaveBeenCalled();
+  });
+});

package/spec/tests/utils/dialog_spec.js

@@ -0,0 +1,297 @@
+import DialogUtils from 'src/host/utils/dialog';
+
+describe('dialog utils', () => {
+  describe('_size', () => {
+    it('returns xlarge if given size is x-large', () => {
+      const options = {
+        size: 'x-large'
+      };
+      expect(DialogUtils._size(options)).toEqual('xlarge');
+    });
+
+    it('returns fullscreen if 100% height and width', () => {
+      const options = {
+        height: '100%',
+        width: '100%'
+      };
+      expect(DialogUtils._size(options)).toEqual('fullscreen');
+    });
+
+    it('returns maximum even if 100% height and width', () => {
+      const options = {
+        size: 'maximum',
+        height: '100%',
+        width: '100%'
+      };
+      expect(DialogUtils._size(options)).toEqual('maximum');
+    });
+
+    it('does nothing if size is undefined', () => {
+      const options = {};
+      expect(DialogUtils._size(options)).not.toBeDefined();
+    });
+
+    it('returns original size', () => {
+      const options = {
+        size: 'small'
+      };
+      expect(DialogUtils._size(options)).toEqual('small');
+    });
+
+    it('returns original dimensions', () => {
+      const options = {
+        width: '100px',
+        height: '200px'
+      };
+      expect(DialogUtils._size(options)).not.toBeDefined();
+    });
+  });
+
+  describe('_header', () => {
+    it('handles string', () => {
+      const text = 'this is my header';
+      expect(DialogUtils._header(text)).toEqual(text);
+    });
+
+    it('handles object', () => {
+      const text = {
+        value: 'this is my header'
+      };
+      expect(DialogUtils._header(text)).toEqual(text.value);
+    });
+  });
+
+  describe('_hint', () => {
+    it('handles string', () => {
+      const text = 'this is a hint';
+      expect(DialogUtils._hint(text)).toEqual(text);
+    });
+
+    it('everything else returns blank', () => {
+      const text = {
+        value: 'this is a hint'
+      };
+      expect(DialogUtils._hint(text)).toEqual('');
+    });
+  });
+
+  describe('_chrome', () => {
+    it('defaults to false', () => {
+      const options = {};
+      expect(DialogUtils._chrome(options)).toBe(false);
+    });
+
+    it('returns original if defined and boolean', () => {
+      const options = {
+        chrome: true
+      };
+      expect(DialogUtils._chrome(options)).toBe(options.chrome);
+    });
+
+    it('returns false if chrome is not a boolean', () => {
+      const options = {
+        chrome: 'yes'
+      };
+      expect(DialogUtils._chrome(options)).toBe(false);
+    });
+
+    it('returns true if size is fullscreen', () => {
+      const options = {
+        size: 'fullscreen'
+      };
+      expect(DialogUtils._chrome(options)).toBe(true);
+    });
+
+    it('returns false if size is maximum', () => {
+      const options = {
+        size: 'maximum'
+      };
+      expect(DialogUtils._chrome(options)).toBe(false);
+    });
+  });
+
+  describe('_width', () => {
+    it('returns undefined if size is defined', () => {
+      const options = {
+        size: 'medium'
+      };
+      expect(DialogUtils._width(options)).not.toBeDefined();
+    });
+
+    it('returns formatted width', () => {
+      const options = {
+        width: '100'
+      };
+      expect(DialogUtils._width(options)).toEqual(`${options.width}px`);
+    });
+
+    it('returns formatted width width %', () => {
+      const options = {
+        width: '100%'
+      };
+      expect(DialogUtils._width(options)).toEqual(options.width);
+    });
+  });
+
+  describe('_height', () => {
+    it('returns undefined if size is defined', () => {
+      const options = {
+        size: 'medium'
+      };
+      expect(DialogUtils._height(options)).not.toBeDefined();
+    });
+
+    it('returns formatted height', () => {
+      const options = {
+        height: '100'
+      };
+      expect(DialogUtils._height(options)).toEqual(`${options.height}px`);
+    });
+
+    it('returns formatted height with %', () => {
+      const options = {
+        height: '100%'
+      };
+      expect(DialogUtils._height(options)).toEqual(options.height);
+    });
+  });
+
+  describe('_actions', () => {
+    it('default actions if no actions defined', () => {
+      const options = {};
+      const actions = DialogUtils._actions(options);
+      expect(actions.length).toEqual(2);
+      expect(actions[0].name).toEqual('submit');
+      expect(actions[0].identifier).toEqual('submit');
+      expect(actions[0].text).toEqual('Submit');
+      expect(actions[0].type).toEqual('primary');
+      expect(actions[1].name).toEqual('cancel');
+      expect(actions[1].identifier).toEqual('cancel');
+      expect(actions[1].text).toEqual('Cancel');
+      expect(actions[1].type).toEqual('link');
+      expect(actions[1].immutable).toBe(true);
+    });
+
+    it('return defined actions', () => {
+      const options = {
+        actions: [
+          {
+            name: 'someaction',
+            identifier: 'someid',
+            text: 'some button',
+            type: 'primary'
+          }
+        ]
+      };
+      const actions = DialogUtils._actions(options);
+      expect(actions.length).toEqual(0);
+    });
+
+    it('returns buttons', () => {
+      const options = {
+        buttons: [
+          {
+            identifier: 'someid',
+            text: 'some button'
+          }
+        ]
+      };
+      const actions = DialogUtils._actions(options);
+      expect(actions.length).toEqual(3);
+      expect(actions[2].identifier).toEqual(options.buttons[0].identifier);
+      expect(actions[2].text).toEqual(options.buttons[0].text);
+    });
+  });
+
+  describe('_id', () => {
+    it('return random id if not a string', () => {
+      const str = {
+        some: 'thing'
+      };
+      const id = DialogUtils._id(str);
+      expect(id).not.toEqual(str);
+      expect(typeof id === 'string').toBe(true);
+    });
+
+    it('return original string', () => {
+      const str = 'somestring';
+      expect(DialogUtils._id(str)).toEqual(str);
+    });
+
+  });
+
+  describe('_buttons', () => {
+    it('return empty array if given buttons is not an array', () => {
+      const options = {
+        buttons: 'some string'
+      };
+      expect(DialogUtils._buttons(options)).toEqual([]);
+    });
+
+    it('text, identifier and disabled', () => {
+      const buttonText = 'some text';
+      const buttonIdentifier = 'some id';
+      const buttonDisabled = true;
+      const options = {
+        buttons: [
+          {
+            text: buttonText,
+            identifier: buttonIdentifier,
+            disabled: buttonDisabled
+          }
+        ]
+      };
+      const buttons = DialogUtils._buttons(options);
+      expect(buttons.length === 1).toBe(true);
+      expect(buttons[0].text).toEqual(buttonText);
+      expect(buttons[0].identifier).toEqual(buttonIdentifier);
+      expect(buttons[0].disabled).toEqual(buttonDisabled);
+      expect(buttons[0].custom).toBe(true);
+      expect(buttons[0].type).toEqual('secondary');
+    });
+
+    it('text and identifier not defined', () => {
+      const options = {
+        buttons: [
+          {}
+        ]
+      };
+      const buttons = DialogUtils._buttons(options);
+      expect(buttons.length === 1).toBe(true);
+      expect(buttons[0].text).not.toBeDefined();
+      expect(buttons[0].identifier).toBeDefined();
+      expect(buttons[0].disabled).toBe(false);
+    });
+
+  });
+
+  describe('moduleOptionsFromGlobal', () => {
+    const options = {
+      options: {
+        someKey: 'someVal'
+      }
+    };
+    const defaults = {
+      chrome: true,
+      hostFrameOffset: 1
+    };
+
+    beforeEach(() => {
+      window._AP = {
+        dialogModules: {
+          addonKey: {
+            moduleKey: options
+          }
+        }
+      }
+    });
+
+    it('returns false if not defined', () => {
+      expect(DialogUtils.moduleOptionsFromGlobal('notAddonKey', 'something else')).toBe(false);
+    });
+
+    it('returns expected options with defaults', () => {
+      expect(DialogUtils.moduleOptionsFromGlobal('addonKey', 'moduleKey')).toEqual($.extend({}, defaults, options.options));
+    });
+  });
+});

package/spec/tests/utils/host_util_spec.js

@@ -0,0 +1,45 @@
+import util from 'src/host/util';
+
+describe('host util', () => {
+  describe('escapeSelector', () => {
+    it('throws an error when selector not defined', () => {
+      expect(() => {
+        util.escapeSelector();
+      }).toThrow();
+    });
+
+    it('escapes given string', () => {
+      const testString = '!"#$%&\'()*+,.\/:;<=>?@[\\\]^`{|}~test';
+      const expectedString = '\\!\\"\\#\\$\\%\\&\\\'\\(\\)\\*\\+\\,\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\\]\\^\\`\\{\\|\\}\\~test';
+      expect(util.escapeSelector(testString)).toEqual(expectedString);
+    });
+
+    it('does not escape string if there are no special characters', () => {
+      const testString = 'this is a string';
+      expect(util.escapeSelector(testString)).toEqual(testString);
+    });
+  });
+
+  describe('stringToDimension', () => {
+    it('return formatted string (px) given a string', () => {
+      const dimension = '100px';
+      expect(util.stringToDimension(dimension)).toEqual(dimension);
+    });
+
+    it('return formatted string (%) given a string', () => {
+      const dimension = '100%';
+      expect(util.stringToDimension(dimension)).toEqual(dimension);
+    });
+
+    it('defaults to px', () => {
+      const dimension = '100';
+      expect(util.stringToDimension(dimension)).toEqual(`${dimension}px`);
+    });
+
+    it('defaults to px (number)', () => {
+      const dimension = 100;
+      expect(util.stringToDimension(dimension)).toEqual(`${dimension}px`);
+    });
+  });
+});
+

package/spec/tests/utils/iframe_spec.js

@@ -0,0 +1,41 @@
+import IframeUtils from 'src/host/utils/iframe';
+
+describe('iframe utils', () => {
+  describe('optionsToAttributes', () => {
+
+    it('returns empty object if options is not an object', () => {
+      expect(IframeUtils.optionsToAttributes('not an object')).toEqual({});
+    });
+
+    it('returns sanitised dimensions', () => {
+      const options = {
+        width: '100',
+        height: '500',
+        size: 'medium'
+      };
+
+      const attributes = IframeUtils.optionsToAttributes(options);
+      expect(attributes.width).toEqual(`${options.width}px`);
+      expect(attributes.height).toEqual(`${options.height}px`);
+      expect(attributes.size).not.toBeDefined();
+    });
+
+    it('returns sanitised sandbox', () => {
+      const sandbox = 'allow-downloads allow-forms allow-modals allow-popups allow-scripts allow-same-origin allow-top-navigation-by-user-activation allow-storage-access-by-user-activation';
+      const attributes = IframeUtils.optionsToAttributes({ sandbox });
+      // could be anything based on browser support, so just check not-empty
+      expect(attributes.sandbox.length > 0).toBe(true);
+    });
+
+    it('does not return sandbox if not present', () => {
+      const attributes = IframeUtils.optionsToAttributes({});
+      expect(typeof attributes.sandbox).toEqual('undefined');
+    });
+
+    it('does not return sandbox if wrong type', () => {
+      const sandbox = {};
+      const attributes = IframeUtils.optionsToAttributes({ sandbox });
+      expect(typeof attributes.sandbox).toEqual('undefined');
+    });
+  });
+});

package/spec/tests/utils/jwt_spec.js

@@ -0,0 +1,135 @@
+import jwtUtils from 'src/host/utils/jwt';
+import base64 from 'src/host/utils/base64';
+
+describe('jwt utils', () => {
+
+  describe('funky characters decoding', () => {
+    it('Accented characters', () => {
+      const claims = {
+        user: 'aàáâãäåçèéêëìíîðñòôõööz'
+      };
+      const encodedClaims = 'eyJ1c2VyIjoiYcOgw6HDosOjw6TDpcOnw6jDqcOqw6vDrMOtw67DsMOxw7LDtMO1w7bDtnoifQ';
+      const jwt = `alsdjfaj123.${encodedClaims}.khsadlj234`;
+      expect(jwtUtils.parseJwtClaims(jwt)).toEqual(claims);
+    });
+
+    it('Asian characters', () => {
+      const claims = {
+        user: 'a国際交流基金海外運営専門員z'
+      };
+      const encodedClaims = 'eyJ1c2VyIjoiYeWbvemam-S6pOa1geWfuumHkea1t-WklumBi-WWtuWwgumWgOWToXoifQ';
+      const jwt = `alsdjfaj123.${encodedClaims}.khsadlj234`;
+      expect(jwtUtils.parseJwtClaims(jwt)).toEqual(claims);
+    });
+
+    it('Good international string characters', () => {
+      const claims = {
+        user: 'àáâãäåçèéêëìíîðñòôõöö 国際交流абвгдежзبْجَدِيَّة عَرَبِيَّة‎עִבְרִיתदिंदुसरोवरλληνικ'
+      };
+      const encodedClaims = 'eyJ1c2VyIjoiw6DDocOiw6PDpMOlw6fDqMOpw6rDq8Osw63DrsOww7HDssO0w7XDtsO2IOWb' +
+          'vemam-S6pOa1gdCw0LHQstCz0LTQtdC20LfYqNmS2KzZjtiv2ZDZitmO2ZHYqSDYudmO2LHZjtio2ZDZitmO2ZHYqe' +
+          'KAjtei1rTXkdaw16jWtNeZ16rgpKbgpL_gpILgpKbgpYHgpLjgpLDgpYvgpLXgpLDOu867zrfOvc65zroifQ';
+      const jwt = `alsdjfaj123.${encodedClaims}.khsadlj234`;
+      expect(jwtUtils.parseJwtClaims(jwt)).toEqual(claims);
+    });
+
+    it('Good international string characters', () => {
+      const claims = {
+        user: 'a♬♬♫b'
+      };
+      const encodedClaims = 'eyJ1c2VyIjoiYeKZrOKZrOKZq2IifQ';
+      const jwt = `alsdjfaj123.${encodedClaims}.khsadlj234`;
+      expect(jwtUtils.parseJwtClaims(jwt)).toEqual(claims);
+    });
+
+
+  });
+
+  describe('parseJwtIssuer', () => {
+    it('returns iss from claim', () => {
+      const iss = 'jira:59975d67-4ca0-4e9e-9960-123412312';
+      const claim = {
+        iss: iss
+      };
+      const encodedClaim = base64.encode(JSON.stringify(claim));
+      const jwt = `alsdjfaj123.${encodedClaim}.khsadlj234`;
+      expect(jwtUtils.parseJwtIssuer(jwt)).toEqual(iss);
+    })
+  });
+
+  describe('parseJwtClaims', () => {
+    it('throws when jwt is empty of null', () => {
+      expect(() => {
+        jwtUtils.parseJwtClaims(null);
+      }).toThrow();
+
+      expect(() => {
+        jwtUtils.parseJwtClaims('');
+      }).toThrow();
+    });
+
+    it('throws when just does not contain 2 periods', () => {
+      expect(() => {
+        jwtUtils.parseJwtClaims('invalidjwt');
+      }).toThrow();
+
+      expect(() => {
+        jwtUtils.parseJwtClaims('invalid.jwt');
+      }).toThrow();
+    });
+
+    it('throws when encoded claims is empty or null', () => {
+      expect(() => {
+        jwtUtils.parseJwtClaims('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ');
+      }).toThrow();
+    });
+
+    it('returns claims', () => {
+      const jwt = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ';
+      const expectedClaims = {
+        sub: '1234567890',
+        name: 'John Doe',
+        admin: true
+      };
+      expect(jwtUtils.parseJwtClaims(jwt)).toEqual(expectedClaims);
+    });
+  });
+
+  describe('isJwtExpired', () => {
+    it('returns true if expired', () => {
+      const claim = {
+        exp: Math.floor(Date.now() / 1000) - 60
+      };
+      const encodedClaim = base64.encode(JSON.stringify(claim));
+      const jwt = `alsdjfaj123.${encodedClaim}.khsadlj234`;
+      expect(jwtUtils.isJwtExpired(jwt)).toBe(true);
+    });
+
+    it('returns false if not expired', () => {
+      const claim = {
+        exp: Math.floor(Date.now() / 1000) + 60
+      };
+      const encodedClaim = base64.encode(JSON.stringify(claim));
+      const jwt = `alsdjfaj123.${encodedClaim}.khsadlj234`;
+      expect(jwtUtils.isJwtExpired(jwt)).toBe(false);
+    });
+
+    it('returns true if expired with skew', () => {
+      const claim = {
+        exp: Math.floor(Date.now() / 1000) + 60
+      };
+      const encodedClaim = base64.encode(JSON.stringify(claim));
+      const jwt = `alsdjfaj123.${encodedClaim}.khsadlj234`;
+      expect(jwtUtils.isJwtExpired(jwt, 120)).toBe(true);
+    });
+
+    it('returns false if not expired with skew', () => {
+      const claim = {
+        exp: Math.floor(Date.now() / 1000) + 120
+      };
+      const encodedClaim = base64.encode(JSON.stringify(claim));
+      const jwt = `alsdjfaj123.${encodedClaim}.khsadlj234`;
+      expect(jwtUtils.isJwtExpired(jwt, 120)).toBe(false);
+    });
+  });
+});

package/spec/tests/utils/url_spec.js

@@ -0,0 +1,37 @@
+import UrlUtils from 'src/host/utils/url';
+import base64 from 'src/host/utils/base64';
+
+describe('url utils', () => {
+  describe('isJwtExpired', () => {
+    it('returns true when jwt is expired', () => {
+      const claim = {
+        exp: Math.floor(Date.now() / 1000) - 60
+      };
+      const encodedClaim = base64.encode(JSON.stringify(claim));
+      const url = `https://some.url.com?jwt=alsdjfaj123.${encodedClaim}.khsadlj234`;
+      expect(UrlUtils.isJwtExpired(url)).toBe(true);
+    });
+
+    it('returns false when jwt is not expired', () => {
+      const claim = {
+        exp: Math.floor(Date.now() / 1000) + 70
+      };
+      const encodedClaim = base64.encode(JSON.stringify(claim));
+      const url = `https://some.url.com?jwt=alsdjfaj123.${encodedClaim}.khsadlj234`;
+      expect(UrlUtils.isJwtExpired(url)).toBe(false);
+    });
+  });
+
+  describe('hasJwt', () => {
+    it('returns false when jwt is not present in url', () => {
+      const url = 'https://some.url.com';
+      expect(!!UrlUtils.hasJwt(url)).toBe(false);
+    });
+
+    it('returns true when jwt is present in url', () => {
+      const jwt = 'test.test.test';
+      const url = `https://some.url.com?jwt=${jwt}`;
+      expect(UrlUtils.hasJwt(url)).toBe(true);
+    });
+  });
+});

package/spec/tests/utils/waitUntilReadyNextTick.js

@@ -0,0 +1,5 @@
+export function waitUntilReadyNextTick(callback) {
+  $(() => {
+    setTimeout(callback, 1);
+  })
+}