@atlassian/atlassian-connect-js 5.3.190

package/spec/tests/dialog_webitem_spec.js

@@ -0,0 +1,183 @@
+import DialogWebitem from 'src/host/components/dialog_webitem';
+import 'src/host/components/webitem';
+import WebItemActions from 'src/host/actions/webitem_actions';
+import 'src/host/components/dialog_extension';
+import EventDispatcher from 'src/host/dispatchers/event_dispatcher';
+import baseDialogComponentTests from 'fixtures/base_dialog_component_tests';
+import { waitUntilReadyNextTick } from './utils/waitUntilReadyNextTick';
+
+describe('Dialog Webitem', () => {
+  afterEach(() => {
+    $('.aui-dialog2').remove();
+    $('.aui-blanket').remove();
+  });
+
+  var webitemButton;
+
+  beforeEach(() => {
+    window._AP = {
+      dialogOptions: {}
+    };
+
+    $('.aui-dialog2').remove();
+    webitemButton = $('<a />').attr('href', 'https://www.example.com?a.x=b#' + encodeURI(JSON.stringify({productCtx:'{"a.x":"b"}'})));
+    webitemButton.text('i am a webitem');
+    webitemButton.addClass('ap-dialog ap-plugin-key-my-plugin ap-module-key-key ap-link-webitem');
+    webitemButton.appendTo('body');
+  });
+
+  afterEach(() => {
+    window._AP = {};
+    webitemButton.remove();
+  });
+
+  describe('rendering', () => {
+    function waitAndClickDialog(){
+      // The page is already loaded so this fires immediately
+      // However, the MutationObserver callback that adds the handler won't fire until the next tick
+      waitUntilReadyNextTick(() => $('.ap-dialog').click());
+    }
+
+    it('renders a dialog', (done) => {
+      EventDispatcher.registerOnce('after:webitem-invoked:dialog', function(){
+        expect($('.aui-dialog2').length).toBe(1);
+        done();
+      });
+      waitAndClickDialog();
+    });
+
+    it('contains and iframe container', (done) => {
+      EventDispatcher.registerOnce('after:webitem-invoked:dialog', function(){
+        expect($('.aui-dialog2 .ap-iframe-container').length).toBe(1);
+        done();
+      });
+      waitAndClickDialog();
+    });
+
+    it('chromed dialog', (done) => {
+      var extension = {
+        addon_key: 'my-plugin',
+        key: 'key'
+      };
+      var options = baseDialogComponentTests.getChromeOptions();
+      window._AP.dialogOptions[extension.addon_key + '__' + extension.key] = options;
+      EventDispatcher.registerOnce('after:webitem-invoked:dialog', function(){
+        baseDialogComponentTests.testChrome(options);
+        done();
+      });
+      waitAndClickDialog();
+    });
+
+    it('renders a chromed dialog with dimensions', (done) => {
+      var extension = {
+        addon_key: 'my-plugin',
+        key: 'key'
+      };
+      var options = baseDialogComponentTests.getChromeOptions();
+      delete options.size;
+      options.width = '123px';
+      options.height = '100px';
+      window._AP.dialogOptions[extension.addon_key + '__' + extension.key] = options;
+      EventDispatcher.registerOnce('after:webitem-invoked:dialog', function(){
+        baseDialogComponentTests.testChrome(options);
+        done();
+      });
+      waitAndClickDialog();
+    });
+
+    it('renders a chromeless dialog', (done) => {
+      var extension = {
+        addon_key: 'my-plugin',
+        key: 'key'
+      };
+      var options = baseDialogComponentTests.getChromelessOptions();
+      window._AP.dialogOptions[extension.addon_key + '__' + extension.key] = options;
+      EventDispatcher.registerOnce('after:webitem-invoked:dialog', function(){
+        baseDialogComponentTests.testChromeless(options);
+        done();
+      });
+      waitAndClickDialog();
+    });
+
+    it('renders a chromeless dialog with dimensions', (done) => {
+      var extension = {
+        addon_key: 'my-plugin',
+        key: 'key'
+      };
+      var options = baseDialogComponentTests.getChromelessOptions();
+      delete options.size;
+      options.width = '123px';
+      options.height = '100px';
+      window._AP.dialogOptions[extension.addon_key + '__' + extension.key] = options;
+      EventDispatcher.registerOnce('after:webitem-invoked:dialog', function(){
+        baseDialogComponentTests.testChromeless(options);
+        done();
+      });
+      waitAndClickDialog();
+    });
+
+    it('renders a dialog without changing original dialog options', (done) => {
+      var extension = {
+        addon_key: 'my-plugin',
+        key: 'key'
+      };
+      var options = baseDialogComponentTests.getChromeOptions();
+      delete options.size;
+      options.width = '123px';
+      options.height = '100px';
+      window._AP.dialogOptions[extension.addon_key + '__' + extension.key] = options;
+      EventDispatcher.registerOnce('after:webitem-invoked:dialog', function(){
+        expect(window._AP.dialogOptions['my-plugin__key']).toEqual(options);
+        done();
+      });
+      waitAndClickDialog();
+    });
+
+  });
+
+  describe('triggers', () => {
+    beforeEach(() => {
+      window._AP = {
+        _convertConnectOptions: function(data){
+          return {
+            options: {
+              productContext: JSON.parse(data.productCtx)
+            }
+          };
+        }
+      }
+    });
+
+    afterEach(() => {
+      delete window._AP._convertConnectOptions;
+    });
+
+    it('is set to be triggered by click', () => {
+      expect(DialogWebitem.getWebItem().triggers).toEqual(['click']);
+    });
+
+    it('responds to a click event', (done) => {
+      var spy = jasmine.createSpy('spy');
+      spyOn(WebItemActions, 'webitemInvoked');
+      waitUntilReadyNextTick(() => {
+        $('.ap-dialog').click();
+        expect(WebItemActions.webitemInvoked.calls.count()).toEqual(1);
+        done();
+      });
+    });
+
+    it('includes product context', (done) => {
+      var spy = jasmine.createSpy('spy');
+      spyOn(WebItemActions, 'webitemInvoked');
+      waitUntilReadyNextTick(() => {
+        $('.ap-dialog').click();
+        var extensionObj = WebItemActions.webitemInvoked.calls.first().args[1].extension;
+        expect(extensionObj.options.productContext).toEqual({'a.x': 'b'});
+        done();
+      });
+    });
+
+  });
+
+
+});

package/spec/tests/dropdown_module_spec.js

@@ -0,0 +1,77 @@
+import DropdownModule from 'src/host/modules/dropdown';
+import EventDispatcher from 'src/host/dispatchers/event_dispatcher';
+import EventActions from 'src/host/actions/event_actions';
+import HostApi from 'src/host/host-api';
+
+describe('dropdown api module', () => {
+  const frameworkAdaptor = HostApi.getFrameworkAdaptor();
+
+  const fakeCallback = function(){};
+  fakeCallback._context = {
+    extension: {
+      extension_id: 'some-extension-id'
+    }
+  };
+
+  const providerSpy = jasmine.createSpyObj('moduleProvider', [
+    'registerItemNotifier',
+    'create',
+    'hide',
+    'showAt',
+    'itemActivated',
+    'itemDisabled'
+  ]);
+
+  let dropdownProvider = {
+    getModuleRegistrationName: function() {
+      return 'dropdown';
+    },
+    isEnabled: function() {
+      return true;
+    },
+    getProvider: function(){
+      return providerSpy;
+    }
+  };
+  frameworkAdaptor.registerModule(dropdownProvider);
+
+  beforeEach(() => {
+    providerSpy.registerItemNotifier.calls.reset();
+    providerSpy.create.calls.reset();
+    providerSpy.hide.calls.reset();
+    providerSpy.showAt.calls.reset();
+    providerSpy.itemActivated.calls.reset();
+    providerSpy.itemDisabled.calls.reset();
+  });
+
+  describe('create', () => {
+
+    it('formats sections', () => {
+      let options = {
+        dropdownId: 'some-dropdown-id',
+        list: [{
+          heading: 'section heading',
+          list: [
+            {text: 'one'},
+            {text: 'two'}
+          ]
+        }]
+      };
+      let formattedOptions = DropdownModule.create(Object.assign({}, options), fakeCallback);
+      expect(formattedOptions).toEqual({
+        dropdownId: options.dropdownId,
+        dropdownGroups: [{
+          heading: options.list[0].heading,
+          items: [
+            {content: options.list[0].list[0].text},
+            {content: options.list[0].list[1].text}
+          ]
+        }],
+        dropdownItemNotifier: jasmine.any(Function)
+      });
+
+    });
+
+  });
+
+});

package/spec/tests/env_module_spec.js

@@ -0,0 +1,153 @@
+import envModule from 'src/host/modules/env';
+import EventDispatcher from 'src/host/dispatchers/event_dispatcher';
+import {Flags} from '../../src/host/utils/feature-flag';
+
+describe('env module', () => {
+
+  xdescribe('sizeToParent', () => {
+    afterEach(function(){
+      $('.tempiframe').remove();
+      $('.ac-content-page').remove();
+    });
+
+    it('disables resize function', (done) => {
+      var callback = function(){};
+      var $el = $('<iframe class="tempiframe" id="d32idas" />');
+      callback._context = {
+        extension_id: 'd32idas',
+        extension: {
+          id: 'd32idas',
+          $el: $el,
+          options: {
+            isFullPage: true
+          }
+        }
+      };
+
+      $('body').append($el);
+      expect(envModule.resize('10px','10px', callback)).toEqual(true);
+      var resizeSpy = (data) => {
+        if(data.extensionId === callback._context.extension_id) {
+          expect(envModule.resize('10px','10px', callback)).toEqual(false);
+          done();
+          EventDispatcher.unregister('after:iframe-size-to-parent', resizeSpy);
+        }
+      };
+      EventDispatcher.register('after:iframe-size-to-parent', resizeSpy);
+      envModule.sizeToParent(true, callback);
+    });
+
+    it('changes the dimensions of the iframe to fill the rest of the page', (done) => {
+      var $contentPage = $('<div class="ac-content-page" />');
+      var $nav = $('<nav />').css('height', '23px');
+      var $header = $('<header id="header"></header>').append($nav);
+      var callback = function(){};
+      var $el = $('<iframe class="tempiframe" id="zxy123" />').css({
+        border: 0,
+        padding: 0,
+        margin: 0
+      });
+      callback._context = {
+        extension_id: 'zxy123',
+        extension: {
+          id: 'zxy123',
+          $el: $el,
+          options: {
+            isFullPage: true
+          }
+        }
+      };
+
+      $contentPage.append($header);
+      $contentPage.append($el);
+      $('body').append($contentPage);
+      // full height - header - 1px border = scrollbar only on iframe
+      var correctIframeHeight = $(window).height() - 23 - 1;
+      function spy (data){
+        if(data.$el.attr('id') === callback._context.extension_id) {
+          expect($el.height()).toEqual(correctIframeHeight);
+          expect($el.attr('class')).toContain('sized-to-parent');
+          expect($el.css('display')).toEqual('block');
+          EventDispatcher.unregister('iframe-resize', spy);
+          done();
+        }
+      }
+      EventDispatcher.register('iframe-resize', spy);
+      envModule.sizeToParent(false, callback);
+    });
+  });
+
+  describe('resize', () => {
+
+    afterEach(function(){
+      $('.tempiframe').remove();
+    });
+
+    it('triggers the resize function', (done) => {
+      var width = '100px';
+      var height = '120px';
+      var callback = function(){};
+      var $el = $('<iframe class="tempiframe" id="xabc123" />');
+      callback._context = {
+        extension_id: 'xabc123',
+        extension: {
+          id: 'xabc123',
+          $el: $el
+        }
+      };
+      $('body').append($el);
+      function resizeSpy(data){
+        if(data.extension && data.extension.id === callback._context.extension.id){
+          expect(data.width).toEqual(width);
+          expect(data.height).toEqual(height);
+          expect(data.extension.id).toEqual(callback._context.extension.id);
+          EventDispatcher.unregister('after:iframe-resize', resizeSpy);
+          done();
+        }
+      }
+      EventDispatcher.register('after:iframe-resize', resizeSpy);
+      envModule.resize(width, height, callback);
+    });
+
+    it('triggers the resize function once per add-on', (done) => {
+      var width = '110px';
+      var height = '130px';
+      var $el1= $('<iframe class="tempiframe" id="abc1234" />');
+      var callback1 = function(){};
+      callback1._context = {
+        extension_id: 'abc1234',
+        extension: {
+          id: 'abc1234',
+          $el: $el1
+        }
+      };
+
+      var $el2 = $('<iframe class="tempiframe" id="xyz123" />');
+      var callback2 = function(){};
+      callback2._context = {
+        extension_id: 'xyz123',
+        extension: {
+          id: 'xyz123',
+          $el: $el2
+        }
+      };
+
+      var spy = jasmine.createSpy('validator');
+      EventDispatcher.register('iframe-resize', spy);
+      $('body').append($el1);
+      $('body').append($el2);
+      envModule.resize(width, height, callback1);
+      envModule.resize(width, height, callback1);
+      envModule.resize(width, height, callback2);
+      envModule.resize(width, height, callback2);
+
+      setTimeout(function(){
+        expect(spy.calls.count()).toEqual(2);
+        expect(spy.calls.argsFor(0)[0].extension.id).toEqual('abc1234');
+        expect(spy.calls.argsFor(1)[0].extension.id).toEqual('xyz123');
+        EventDispatcher.unregister('iframe-resize', spy);
+      }, 500);
+      done();
+    });
+  });
+});

package/spec/tests/events_spec.js

@@ -0,0 +1,77 @@
+import AP from 'simple-xdm/plugin';
+AP._data.origin = '*'; // prevent AP._registerOnUnload() from failing
+
+import Events from 'src/plugin/events';
+import EventActions from 'src/host/actions/event_actions';
+
+const targetSpecNoDialogs = EventActions.targetSpecNoDialogs;
+
+describe('Plugin events shim', function(){
+  var events = new Events();
+  beforeEach(function(){
+    events._events = {};
+  });
+  it('on binds an event', function(){
+    var spy = jasmine.createSpy('spy');
+    events.on('something', spy);
+    expect(events._events['something'][0]).toEqual(spy);
+  });
+
+  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, {});
+    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]).not.toContain(spy);
+    events.onAny(spy);
+    expect(events._events[events.ANY_PREFIX]).toContain(spy);
+  });
+
+  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);
+  });
+
+  it('targetSpecNoDialogs filters events from dialog modules', function(){
+    const registration = {
+      extension: {
+        options: {
+          moduleType: 'dialogs',
+        },
+      },
+    };
+    expect(targetSpecNoDialogs(registration)).toEqual(false);
+  });
+
+  it('targetSpecNoDialogs does not filter events from non-dialog modules', function(){
+    const registration = {
+      extension: {
+        options: {
+          moduleType: 'anything',
+        },
+      },
+    };
+    expect(targetSpecNoDialogs(registration)).toEqual(true);
+  });
+
+});

package/spec/tests/extension_configuration_options_store_spec.js

@@ -0,0 +1,25 @@
+import ExtensionConfigurationOptionsStore from 'src/host/stores/extension_configuration_options_store';
+import SimpleXdmUtils from 'src/host/utils/simplexdm';
+
+describe('Extension Configuration Options Store', () => {
+
+  beforeEach(() => {
+    ExtensionConfigurationOptionsStore.store = {};
+  });
+
+  it('sets an option that is added to the iframe', () => {
+    ExtensionConfigurationOptionsStore.set('crev', '1.2.3.4.5');
+    var simpleXdmExtension = SimpleXdmUtils.createSimpleXdmExtension({
+      addon_key: 'abc123',
+      key: 'some-module-key',
+      url: 'http://www.example.com',
+      options: {
+        noDOM: true
+      }
+    });
+    expect(simpleXdmExtension.extension.options.globalOptions).toEqual({'crev': '1.2.3.4.5'});
+    var parsedIframeName = JSON.parse(simpleXdmExtension.iframeAttributes.name);
+    expect(parsedIframeName.options.globalOptions.crev).toEqual('1.2.3.4.5');
+  });
+
+});

package/spec/tests/flag_module_provider_spec.js

@@ -0,0 +1,79 @@
+import FlagModule from 'src/host/modules/flag';
+import ModuleProviders from 'src/host/module-providers';
+import EventActions from 'src/host/actions/event_actions';
+import { acjsFrameworkAdaptor } from 'src/host/ACJSFrameworkAdaptor';
+
+const callback = () => {};
+callback._id = 'some-extension-id';
+callback._context = {
+  extension: {
+    addon_key: 'some-addon-key',
+    key: 'some-module-key',
+    options: jasmine.objectContaining({})
+  }
+};
+
+const appProviderSpy = {
+  registerUnmountCallback: jasmine.createSpy('registerUnmountCallback')
+};
+
+const flagProviderSpy = {
+  create: jasmine.createSpy('create'),
+  close: jasmine.createSpy('close')
+};
+
+class FlagModuleSpy {
+  constructor(providerSpy) {
+    this.providerSpy = flagProviderSpy;
+  }
+  isEnabled() {
+    return true;
+  }
+  getModuleRegistrationName() {
+    return 'flag';
+  }
+  getProvider() {
+    return this.providerSpy;
+  }
+};
+
+acjsFrameworkAdaptor.registerModule(new FlagModuleSpy(flagProviderSpy));
+
+describe('AP.flag', () => {
+
+  const flagOptions = {
+    type: 'some type',
+    title: 'some title',
+    body: 'some body',
+    actions: {
+      key: 'some action text'
+    }
+  };
+
+  beforeEach(() => {
+    flagProviderSpy.create.calls.reset();
+    flagProviderSpy.close.calls.reset();
+    appProviderSpy.registerUnmountCallback.calls.reset();
+  });
+
+  describe('.create()', () => {
+    it('does not invoke registerUnmountCallback if provider not registered', () => {
+      ModuleProviders.registerProvider('addon', null);
+      new FlagModule.create.constructor(flagOptions, callback);
+      expect(appProviderSpy.registerUnmountCallback).not.toHaveBeenCalled();
+    });
+
+    it('does not invoke registerUnmountCallback if not implemented in provider', () => {
+      ModuleProviders.registerProvider('addon', {});
+      new FlagModule.create.constructor(flagOptions, callback);
+      expect(appProviderSpy.registerUnmountCallback).not.toHaveBeenCalled();
+    });
+
+    it('invokes registerUnmountCallback if available', () => {
+      ModuleProviders.registerProvider('addon', appProviderSpy);
+      new FlagModule.create.constructor(flagOptions, callback);
+      expect(appProviderSpy.registerUnmountCallback.calls.count()).toEqual(1);
+    });
+  });
+
+});