@atlassian/atlassian-connect-js 5.3.190

package/spec/tests/messages_module_spec.js

@@ -0,0 +1,108 @@
+import MessagesModule from 'src/host/modules/messages';
+import _ from 'lodash';
+
+describe('messages module', () => {
+  var msgCallback = function () { };
+  msgCallback._id = 'abc123';
+  msgCallback._context = {
+    extension: {}
+  };
+
+  beforeEach(() => {
+    $('.aui-message').remove();
+  });
+
+  describe('constructor', () => {
+    it('creates a generic flag', () => {
+      var testTitle = 'some test title';
+      var testBody = 'some test body';
+      MessagesModule.generic.constructor(testTitle, testBody, {}, msgCallback);
+      expect($('.aui-message-generic').length).toEqual(1);
+      expect(_.includes($('.aui-message-generic').first().text(), testTitle)).toBe(true);
+      expect(_.includes($('.aui-message-generic').first().text(), testBody)).toBe(true);
+    });
+
+    it('creates a error flag', () => {
+      var testTitle = 'some test title';
+      var testBody = 'some test body';
+      MessagesModule.error.constructor(testTitle, testBody, {}, msgCallback);
+      expect($('.aui-message-error').length).toEqual(1);
+      expect(_.includes($('.aui-message-error').first().text(), testTitle)).toBe(true);
+      expect(_.includes($('.aui-message-error').first().text(), testBody)).toBe(true);
+    });
+
+    it('creates a warning flag', () => {
+      var testTitle = 'some test title';
+      var testBody = 'some test body';
+      MessagesModule.warning.constructor(testTitle, testBody, {}, msgCallback);
+      expect($('.aui-message-warning').length).toEqual(1);
+      expect(_.includes($('.aui-message-warning').first().text(), testTitle)).toBe(true);
+      expect(_.includes($('.aui-message-warning').first().text(), testBody)).toBe(true);
+    });
+
+    it('creates a success flag', () => {
+      var testTitle = 'some test title';
+      var testBody = 'some test body';
+      MessagesModule.success.constructor(testTitle, testBody, {}, msgCallback);
+      expect($('.aui-message-success').length).toEqual(1);
+      expect(_.includes($('.aui-message-success').first().text(), testTitle)).toBe(true);
+      expect(_.includes($('.aui-message-success').first().text(), testBody)).toBe(true);
+    });
+
+    it('creates a info flag', () => {
+      var testTitle = 'some test title';
+      var testBody = 'some test body';
+      MessagesModule.info.constructor(testTitle, testBody, {}, msgCallback);
+      expect($('.aui-message-info').length).toEqual(1);
+      expect(_.includes($('.aui-message-info').first().text(), testTitle)).toBe(true);
+      expect(_.includes($('.aui-message-info').first().text(), testBody)).toBe(true);
+    });
+
+    it('creates a hint flag', () => {
+      var testTitle = 'some test title';
+      var testBody = 'some test body';
+      MessagesModule.hint.constructor(testTitle, testBody, {}, msgCallback);
+      expect($('.aui-message-hint').length).toEqual(1);
+      expect(_.includes($('.aui-message-hint').first().text(), testTitle)).toBe(true);
+      expect(_.includes($('.aui-message-hint').first().text(), testBody)).toBe(true);
+      expect($('.aui-message-hint').first().attr('id')).toEqual(`ap-message-${msgCallback._id}`);
+    });
+  });
+
+  describe('clear', () => {
+    it('closes the message', () => {
+      MessagesModule.info.constructor('testTitle', 'testBody', {}, msgCallback);
+      try {
+        MessagesModule.clear({ _id: msgCallback._id });
+      } catch (e) {
+        // this is needed because _destroy will not be available
+      }
+      expect($('.aui-message').length).toEqual(0);
+    });
+
+    it('does not close the message if not the correct id', () => {
+      MessagesModule.info.constructor('testTitle', 'testBody', {}, msgCallback);
+      try {
+        MessagesModule.clear({ _id: 'not the right one' });
+      } catch (e) {
+        // this is needed because _destroy will not be available
+      }
+      expect($('.aui-message').length).toEqual(1);
+    });
+  });
+
+  describe('onClose', () => {
+    it('calls the callback when message closes', () => {
+      MessagesModule.info.constructor('testTitle', 'testBody', {}, msgCallback);
+      var callbackSpy = jasmine.createSpy('callback');
+      MessagesModule.onClose({ _id: msgCallback._id }, callbackSpy);
+      try {
+        MessagesModule.clear({ _id: msgCallback._id });
+      } catch (e) {
+        // this is needed because _destroy will not be available
+      }
+      expect(callbackSpy).toHaveBeenCalled();
+    });
+  });
+
+});

package/spec/tests/meta_spec.js

@@ -0,0 +1,71 @@
+import Meta from 'src/plugin/meta';
+
+describe('meta', () => {
+  beforeEach(()=> {
+    var apMetaTag = document.createElement('meta');
+    var otherMetaTag = document.createElement('meta');
+    var contentlessMetaTag = document.createElement('meta');
+    apMetaTag.setAttribute('name', 'ap-test-meta');
+    apMetaTag.setAttribute('content', 'some content');
+    otherMetaTag.setAttribute('name', 'other-meta');
+    otherMetaTag.setAttribute('content', 'some other content');
+    contentlessMetaTag.setAttribute('name', 'ap-contentless-meta');
+    document.head.appendChild(apMetaTag);
+    document.head.appendChild(otherMetaTag);
+    document.head.appendChild(contentlessMetaTag);
+  });
+  describe('getMeta', () => {
+    it('should return content of existing meta tags', () => {
+      expect(Meta.getMeta('test-meta')).toEqual('some content');
+    });
+
+    it('should return undefined for non-existent meta tags', () => {
+      expect(Meta.getMeta('non-existent')).not.toBeDefined();
+    });
+
+    it('should only get meta tags that are prefixed with ap', () => {
+      expect(Meta.getMeta('other-meta')).not.toBeDefined();
+    });
+
+    it('should return null when content of meta tag is not defined', () => {
+      expect(Meta.getMeta('contentless-meta')).toBeNull();
+    });
+  });
+
+  describe('localUrl', () => {
+    beforeEach(() => {
+      var localUrlMetaTag = document.createElement('meta');
+      localUrlMetaTag.id = 'localUrlMetaTag';
+      localUrlMetaTag.setAttribute('name', 'ap-local-base-url');
+      localUrlMetaTag.setAttribute('content', 'https://connect.atlassian.com');
+      document.body.appendChild(localUrlMetaTag);
+    });
+
+    afterEach(() => {
+      var el = document.getElementById('localUrlMetaTag');
+      if (el) {
+        el.parentNode.removeChild(el);
+      }
+    });
+
+    it('gets the correct local base url', () => {
+      expect(Meta.localUrl()).toEqual('https://connect.atlassian.com');
+    });
+
+    it('gets the correct local base url appended with the path', () => {
+      expect(Meta.localUrl('/some-path')).toEqual('https://connect.atlassian.com/some-path');
+    });
+
+    it('returns undefined when local base url meta tag does not exist', () => {
+      var el = document.getElementById('localUrlMetaTag');
+      el.parentNode.removeChild(el);
+      expect(Meta.localUrl()).not.toBeDefined();
+    });
+
+    it('returns undefined when local base url meta tag does not exist (with path)', () => {
+      var el = document.getElementById('localUrlMetaTag');
+      el.parentNode.removeChild(el);
+      expect(Meta.localUrl('some-path')).not.toBeDefined();
+    });
+  });
+});

package/spec/tests/module_args_spec.js

@@ -0,0 +1,52 @@
+import messages from 'src/host/modules/messages';
+import analytics from 'src/host/modules/analytics';
+import events from 'src/host/modules/events';
+import flag from 'src/host/modules/flag';
+import scrollPosition from 'src/host/modules/scroll-position';
+
+var modules = {
+  'messages': messages,
+  'analytics': analytics,
+  'events': events,
+  'flag': flag,
+  'scroll-position': scrollPosition
+};
+
+describe('Module methods with variable args', () => {
+  Object.getOwnPropertyNames(modules).forEach((moduleName) => {
+    describe(moduleName + ' module', () => {
+      Object.getOwnPropertyNames(modules[moduleName]).forEach((methodName) => {
+        it(methodName + ' should work', () => {
+          var fn = modules[moduleName][methodName];
+          var isClass = false;
+          // class proxy
+          if(typeof fn === 'object') {
+            fn = fn.constructor;
+            isClass = true;
+          }
+
+          var fakeCallback = jasmine.createSpy('spy');
+          fakeCallback._id = 'abc123';
+          fakeCallback._context = {
+            extension: {}
+          };
+
+          // -1 because last arg is always callback
+          for(var i=0; i<fn.length-1; i++) {
+            var args = [];
+            args = (i > 0) ? args.concat(new Array(i)) : args;
+            args.push(fakeCallback);
+            expect(function(){
+              if(isClass) {
+                new modules[moduleName][methodName].constructor(...args);
+              } else {
+                fn.apply(null, args);
+              }
+            }).not.toThrow();
+          }
+        });
+      });
+    });
+  }, this);
+
+});

package/spec/tests/observe_spec.js

@@ -0,0 +1,73 @@
+import observe from 'src/host/utils/observe';
+
+describe('observe', () => {
+  it('fires for visible iframe', (done) => {
+    const spy = jasmine.createSpy('observed');
+    const iframe = document.createElement('iframe');
+    document.body.appendChild(iframe);
+    observe(iframe, spy);
+    setTimeout(() => {
+      expect(spy).toHaveBeenCalled();
+      document.body.removeChild(iframe);
+      done();
+    }, 1000);
+  });
+
+  it('fires when iframe scrolls into view', (done) => {
+    const spy = jasmine.createSpy('observed');
+    const iframe = document.createElement('iframe');
+    iframe.style.position = 'absolute';
+    iframe.style.top = '100%';
+    document.body.appendChild(iframe);
+    observe(iframe, spy);
+    setTimeout(() => {
+      expect(spy).not.toHaveBeenCalled();
+      iframe.scrollIntoView();
+      setTimeout(() => {
+        expect(spy).toHaveBeenCalled();
+        document.body.removeChild(iframe);
+        done();
+      }, 1000);
+    }, 1000);
+  });
+
+  it('fires when iframe becomes visible', (done) => {
+    const spy = jasmine.createSpy('observed');
+    const iframe = document.createElement('iframe');
+    iframe.style.display = 'none';
+    document.body.appendChild(iframe);
+    observe(iframe, spy);
+    setTimeout(() => {
+      expect(spy).not.toHaveBeenCalled();
+      iframe.style.display = 'block';
+      setTimeout(() => {
+        expect(spy).toHaveBeenCalled();
+        document.body.removeChild(iframe);
+        done();
+      }, 1000);
+    }, 1000);
+  });
+
+  it('doesn\'t fire for invisible iframe', (done) => {
+    const spy = jasmine.createSpy('observed');
+    const iframe = document.createElement('iframe');
+    iframe.style.display = 'none';
+    document.body.appendChild(iframe);
+    observe(iframe, spy);
+    setTimeout(() => {
+      expect(spy).not.toHaveBeenCalled();
+      document.body.removeChild(iframe);
+      done();
+    }, 1000);
+  });
+
+  it('doesn\'t fire for detached iframe', (done) => {
+    const spy = jasmine.createSpy('observed');
+    const iframe = document.createElement('iframe');
+    observe(iframe, spy);
+    setTimeout(() => {
+      expect(spy).not.toHaveBeenCalled();
+      done();
+    }, 1000);
+  });
+});

package/spec/tests/public_events.spec.js

@@ -0,0 +1,102 @@
+import AP from 'simple-xdm/plugin';
+AP._data.origin = '*'; // prevent AP._registerOnUnload() from failing
+
+import events from 'src/plugin/public-events';
+
+describe('Public plugin events shim', function(){
+  beforeEach(function(){
+    events._events = {};
+  });
+
+  it('on binds an event', function(){
+    var spy = jasmine.createSpy('spy');
+    events.on('something', spy);
+    expect(events._events['something'].length).toEqual(1);
+  });
+
+  it('on accepts a filter', function(){
+    var spy = jasmine.createSpy('spy');
+    events.on('something', spy, {addonKey: 'abc'});
+    events._events['something'][0].call({}, {
+      sender: {
+        addonKey: 'abc'
+      }
+    });
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('on is not called if filter doesnt match', function(){
+    var spy = jasmine.createSpy('spy');
+    events.on('something', spy, {addonKey: 'abc'});
+    events._events['something'][0].call({}, {
+      sender: {
+        addonKey: 'zxt'
+      }
+    });
+    expect(spy).not.toHaveBeenCalled();
+  });
+
+
+  it('on is not called if filter function doesnt match', function(){
+    var spy = jasmine.createSpy('spy');
+    events.on('something', spy, function(){
+      return false;
+    });
+    events._events['something'][0].call({}, {
+      sender: {
+        addonKey: ''
+      }
+    });
+    expect(spy).not.toHaveBeenCalled();
+  });
+
+
+  it('on is called if filter function matches', function(){
+    var spy = jasmine.createSpy('spy');
+    events.on('something', spy, function(){
+      return true;
+    });
+    events._events['something'][0].call({}, {
+      sender: {
+        addonKey: ''
+      }
+    });
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('off unbinds an event', function(){
+    var spy = jasmine.createSpy('spy');
+    events.on('something', spy);
+    events.off('something', spy);
+    expect(events._events['something']).toEqual(undefined);
+  });
+
+  it('once only emits the event once', function(){
+    var spy = jasmine.createSpy('spy');
+    var eventName = 'zxy';
+    expect(events._events[eventName]).toEqual(undefined);
+    events.once(eventName, spy, {});
+    expect(events._events[eventName].length).toEqual(1);
+    events._events[eventName][0].apply(null, [{sender: {}}]);
+    expect(events._events[eventName]).toEqual(undefined);
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('onAny binds on to any trigger', function(){
+    var spy = jasmine.createSpy('spy');
+    expect(events._events[events.ANY_PREFIX]).toEqual(undefined);
+    events.onAny(spy);
+    expect(events._events[events.ANY_PREFIX].length).toEqual(1);
+  });
+
+  it('offAll unbinds all events with the specified name', function(){
+    var eventName = 'abc123';
+    expect(events._events[eventName]).toEqual(undefined);
+    events.on(eventName, jasmine.createSpy('spy'));
+    events.on(eventName, jasmine.createSpy('spy'));
+    expect(events._events[eventName].length).toEqual(2);
+    events.offAll(eventName);
+    expect(events._events[eventName]).toEqual(undefined);
+  });
+
+});

package/spec/tests/scroll_position_spec.js

@@ -0,0 +1,109 @@
+import ScrollPosition from 'src/host/modules/scroll-position';
+import EventDispatcher from 'src/host/dispatchers/event_dispatcher';
+
+describe('scroll position', () => {
+  beforeEach(() => {
+    window.document.body.style.overflow = 'visible';
+    $('iframe').remove();
+  });
+  afterEach(() => {
+    $('iframe').remove();
+  });
+
+  it('gets the scroll position of parent page', (done) => {
+    var elementId = Math.random().toString(36).substring(2, 8);
+    var callback = function (position) {
+      expect(position).toEqual({
+        scrollY: 2400,
+        scrollX: -100,
+        width: window.innerWidth,
+        height: window.innerHeight
+      });
+      done();
+    };
+    callback._context = {
+      extension: {
+        options: {
+          isFullPage: true
+        }
+      },
+      extension_id: elementId
+    };
+    $('<iframe>').attr({id: elementId}).appendTo('body');
+    $('body').css({
+      height: 5000,
+      margin: 100
+    });
+    window.scrollTo(0, 2500);
+    ScrollPosition.getPosition(callback);
+  });
+
+  it('sets the scroll position of the page', (done) => {
+    var elementId = Math.random().toString(36).substring(2, 8);
+    var $window = $(window);
+    var scrollPosition = 10;
+    var callback = function (position) {
+      expect(position.scrollY).toEqual($window.scrollTop() - $(document.getElementById(elementId)).offset().top);
+      done();
+    };
+    callback._context = {
+      extension: {
+        options: {
+          isFullPage: true
+        }
+      },
+      extension_id: elementId
+    };
+    $('<iframe>').attr({id: elementId}).css({
+      width: '300px',
+      height: '5000px'
+    }).appendTo('body');
+    window.scrollTo(0, 0);
+    ScrollPosition.setVerticalPosition(scrollPosition, callback);
+    ScrollPosition.getPosition(callback);
+  });
+
+  it('scroll.nearTop is triggered when scrolling near the top', (done) => {
+    var extension = {
+      options: {isFullPage: true},
+      id: 'abc123',
+      addon_key: 'some-addon-key',
+      key: 'some-module-key'
+    };
+
+    EventDispatcher.registerOnce('event-dispatch', (data) => {
+      expect(data.type).toEqual('scroll.nearTop');
+      expect(data.targetSpec).toEqual({id: extension.id});
+      expect(data.event).toEqual({});
+      done();
+    });
+    EventDispatcher.dispatch('iframe-bridge-established', {
+      extension: extension
+    });
+    window.scrollTo(0,2);
+  });
+
+  it('scroll.nearBottom is triggered when scrolling near the bottom', (done) => {
+    var extension = {
+      options: {isFullPage: true},
+      id: 'abc123',
+      addon_key: 'some-addon-key',
+      key: 'some-module-key'
+    };
+    EventDispatcher.dispatch('iframe-bridge-established', {
+      extension: extension
+    });
+    window.scrollTo(0,2);
+    EventDispatcher.registerOnce('event-dispatch', (data) => {
+      expect(data.type).toEqual('scroll.nearBottom');
+      expect(data.targetSpec).toEqual({id: extension.id});
+      expect(data.event).toEqual({});
+      done();
+    });
+    window.scrollTo(0,100000);
+  });
+
+
+
+
+});