@atlassian/atlassian-connect-js 5.3.190

package/spec/tests/flag_module_spec.js

@@ -0,0 +1,118 @@
+import FlagModule from 'src/host/modules/flag';
+import EventDispatcher from 'src/host/dispatchers/event_dispatcher';
+import EventActions from 'src/host/actions/event_actions';
+
+describe('flag api module', () => {
+
+  afterEach(() => {
+    $('.aui-flag').remove();
+  });
+
+  it('should return the flag api the correct methods', () => {
+    expect(Object.getOwnPropertyNames(FlagModule)).toEqual(['create']);
+    expect(Object.getOwnPropertyNames(FlagModule.create)).toEqual(['constructor', 'close']);
+  });
+
+  describe('constructor', () => {
+    it('should create a flag', (done) => {
+
+      EventDispatcher.registerOnce('flag-open', (e) => {
+        expect(e.id).toEqual('ap-flag-abc123');
+        expect($('#' + e.id).hasClass('aui-flag')).toBe(true);
+        expect($('#' + e.id).find('.title').text()).toEqual('some title');
+        expect($('#' + e.id).find('.ac-flag-actions a').text()).toEqual('action text');
+        done();
+      });
+
+      var flagCallback = function(){};
+      flagCallback._id = 'abc123';
+      flagCallback._context = {
+        extension: {
+          id: 'an-extension-id'
+        }
+      };
+      new FlagModule.create.constructor({
+        type: 'success',
+        title: 'some title',
+        body: 'the body',
+        actions: {
+          key: 'action text'
+        }
+      }, flagCallback);
+
+    });
+  });
+
+  describe('action', () => {
+    it('should trigger an event on click', () =>{
+      var flagCallback = function(){};
+      flagCallback._id = 'a1';
+      flagCallback._context = {
+        extension: {
+          id: 'an-extension-id'
+        }
+      };
+      var flag = new FlagModule.create.constructor({
+        type: 'success',
+        title: 'some title',
+        body: 'the body',
+        actions: {
+          akey: 'some value'
+        }
+      }, flagCallback);
+      expect($('.ac-flag-actions a').length).toEqual(1);
+      spyOn(EventActions,'broadcast');
+      expect(EventActions.broadcast).not.toHaveBeenCalled();
+      $('.ac-flag-actions a').click();
+      expect(EventActions.broadcast).toHaveBeenCalled();
+      expect(EventActions.broadcast).toHaveBeenCalledWith(
+        'flag.action',
+        flagCallback._context.extension,
+        {
+          flagIdentifier: flagCallback._id,
+          actionIdentifier: 'akey'
+        });
+    });
+  });
+
+  describe('close', () => {
+    it('should close the flag', () =>{
+      var flagCallback = function(){};
+      flagCallback._id = 'abc1234';
+      flagCallback._context = {
+        extension: {}
+      };
+      var flag = new FlagModule.create.constructor({
+        type: 'success',
+        title: 'some title',
+        body: 'the body'
+      }, flagCallback);
+      expect($('.aui-flag').attr('aria-hidden')).toEqual('false');
+      flag.close(flagCallback);
+      expect($('.aui-flag').attr('aria-hidden')).toEqual('true');
+    });
+  });
+
+  describe('on close', () => {
+    it('should set an event hanler', () => {
+      var flagCallback = function(){};
+      flagCallback._id = 'abc1234';
+      flagCallback._context = {
+        extension: {
+          id: 'some-extension-id'
+        }
+      };
+      var flag = new FlagModule.create.constructor({
+        type: 'success',
+        title: 'some title',
+        body: 'the body'
+      }, flagCallback);
+      spyOn(EventActions,'broadcast');
+      expect(EventActions.broadcast).not.toHaveBeenCalled();
+      flag.close(flagCallback);
+      expect(EventActions.broadcast).toHaveBeenCalled();
+      expect(EventActions.broadcast).toHaveBeenCalledWith('flag.close', flagCallback._context.extension, { flagIdentifier: flagCallback._id });
+    });
+  });
+
+});

package/spec/tests/flag_spec.js

@@ -0,0 +1,243 @@
+import FlagComponent from 'src/host/components/flag';
+import FlagActions from 'src/host/actions/flag_actions';
+
+/**
+* Because we have no idea when aui/flag will be available
+* we have to make all these tests async whilst we wait for it.
+*/
+
+describe('Flag Component', () => {
+
+  beforeEach(() => {
+  });
+
+  afterEach(() => {
+    $('.aui-flag').remove();
+  });
+
+  describe('close', () => {
+
+    it('the flag returns a close method', (done) => {
+      window.require(['aui/flag'], () => {
+        var $flag = FlagComponent.render({
+          id: 'some-id',
+          type: 'success',
+          body: 'hello world',
+          title: 'some title'
+        });
+        expect($('.aui-flag').attr('aria-hidden')).toEqual('false');
+        $flag.close();
+        expect($('.aui-flag').attr('aria-hidden')).toEqual('true');
+        done();
+      });
+    });
+
+
+    it('the close action closes the flag', (done) => {
+      window.require(['aui/flag'], () => {
+        var $flag = FlagComponent.render({
+          id: 'some-id',
+          type: 'success',
+          body: 'hello world',
+          title: 'some title'
+        });
+        expect($('.aui-flag').attr('aria-hidden')).toEqual('false');
+        FlagActions.close($flag.attr('id'));
+        expect($('.aui-flag').attr('aria-hidden')).toEqual('true');
+        done();
+      });
+    });
+
+    it('the close action closes the correct flag when multiple flags are open', (done) => {
+      window.require(['aui/flag'], () => {
+        var $flag = FlagComponent.render({
+          id: 'some-id',
+          type: 'success',
+          body: 'hello world',
+          title: 'some title'
+        });
+        var $flag2 = FlagComponent.render({
+          id: 'some-other-id',
+          type: 'success',
+          body: 'hello world 2',
+          title: 'some title 2'
+        });
+        var $flag3 = FlagComponent.render({
+          id: 'some-third-id',
+          type: 'success',
+          body: 'hello world 3',
+          title: 'some title 3'
+        });
+        expect($flag.attr('aria-hidden')).toEqual('false');
+        expect($flag2.attr('aria-hidden')).toEqual('false');
+        expect($flag3.attr('aria-hidden')).toEqual('false');
+        FlagActions.close($flag2.attr('id'));
+        expect($flag.attr('aria-hidden')).toEqual('false');
+        expect($flag2.attr('aria-hidden')).toEqual('true');
+        expect($flag3.attr('aria-hidden')).toEqual('false');
+        done();
+      });
+    });
+
+
+  });
+
+
+  describe('rendering', () => {
+
+    it('renders a flag', (done) => {
+      window.require(['aui/flag'], () => {
+        var $flag = FlagComponent.render({
+          id: 'some-id',
+          type: 'success',
+          body: 'hello world',
+          title: 'some title'
+        });
+        expect($flag.hasClass('aui-flag')).toBe(true);
+        expect($flag.attr('id')).toEqual('ap-flag-some-id');
+        done();
+      });
+    });
+
+    it('renders a html body', (done) => {
+      window.require(['aui/flag'], () => {
+        var $flag = FlagComponent.render({
+          id: 'some-id',
+          type: 'success',
+          body: 'hello <b>world</b>',
+          title: 'some title'
+        });
+        expect($flag.find('b').text()).toEqual('world');
+        done();
+      });
+    });
+
+    it('renders a html body from jQuery', (done) => {
+      window.require(['aui/flag'], () => {
+        var $flag = FlagComponent.render({
+          id: 'some-id',
+          type: 'success',
+          body: $('<p>hello <b>world</b></p>'),
+          title: 'some title'
+        });
+        expect($flag.find('b').text()).toEqual('world');
+        done();
+      });
+    });
+
+    it('renders a plain text title', (done) => {
+      window.require(['aui/flag'], () => {
+        var $flag = FlagComponent.render({
+          id: 'some-id',
+          type: 'success',
+          body: 'hello world',
+          title: 'some title'
+        });
+        expect($flag.find('.title').text()).toEqual('some title');
+        done();
+      });
+    });
+
+    it('escapes a html title', (done) => {
+      window.require(['aui/flag'], () => {
+        var $flag = FlagComponent.render({
+          id: 'some-id',
+          type: 'success',
+          body: 'hello world',
+          title: '<b>some title</b>'
+        });
+        expect($flag.find('.title b').length).toEqual(0);
+        done();
+      });
+    });
+
+    it('escapes a jQuery title', (done) => {
+      window.require(['aui/flag'], () => {
+        var $flag = FlagComponent.render({
+          id: 'some-id',
+          type: 'success',
+          body: 'hello world',
+          title: AJS.$('<b>some title</b>')
+        });
+        expect($flag.find('b').length).toEqual(0);
+        done();
+      });
+    });
+
+    it('renders an action', (done) => {
+      window.require(['aui/flag'], () => {
+        var $flag = FlagComponent.render({
+          id: 'some-id',
+          type: 'success',
+          body: 'hello world',
+          actions: {
+            akey: 'a value'
+          },
+          title: AJS.$('<b>some title</b>')
+        });
+        expect($flag.find('.ac-flag-actions a').length).toEqual(1);
+        expect($flag.find('.ac-flag-actions a').text()).toEqual('a value');
+        done();
+      });
+    });
+    it('renders multiple actions', (done) => {
+      window.require(['aui/flag'], () => {
+        var $flag = FlagComponent.render({
+          id: 'some-id',
+          type: 'success',
+          body: 'hello world',
+          actions: {
+            akey: 'a value',
+            anotherKey: 'another value'
+          },
+          title: AJS.$('<b>some title</b>')
+        });
+        expect($flag.find('.ac-flag-actions a').length).toEqual(2);
+        expect($flag.find('.ac-flag-actions a:first').text()).toEqual('a value');
+        expect($flag.find('.ac-flag-actions a:nth-child(2)').text()).toEqual('another value');
+        done();
+      });
+    });
+
+    it('triggers an event on action click', (done) => {
+      window.require(['aui/flag'], () => {
+        var $flag = FlagComponent.render({
+          id: 'some-id',
+          type: 'success',
+          body: 'hello world',
+          actions: {
+            akey: 'a value'
+          },
+          title: AJS.$('<b>some title</b>')
+        });
+        spyOn(FlagActions, 'actionInvoked');
+        expect(FlagActions.actionInvoked).not.toHaveBeenCalled();
+        $flag.find('.ac-flag-actions a').click();
+        expect(FlagActions.actionInvoked).toHaveBeenCalled();
+        expect(FlagActions.actionInvoked).toHaveBeenCalledWith('akey', 'some-id');
+        done();
+      });
+    });
+
+
+    it('escapes html in actions', (done) => {
+      var actions = {};
+      actions['<b>hello</b>'] = '<i>world</i>';
+      window.require(['aui/flag'], () => {
+        var $flag = FlagComponent.render({
+          id: 'some-id',
+          type: 'success',
+          body: 'hello world',
+          actions: actions,
+          title: AJS.$('<b>some title</b>')
+        });
+        expect($flag.find('.ac-flag-actions a').length).toEqual(1);
+        expect($flag.find('.ac-flag-actions a').html()).toEqual('&lt;i&gt;world&lt;/i&gt;');
+        expect($flag.find('.ac-flag-actions a').text()).toEqual('<i>world</i>');
+        done();
+      });
+    });
+
+  });
+
+});

package/spec/tests/host-api_spec.js

@@ -0,0 +1,220 @@
+import HostApi from 'src/host/host-api';
+import EventDispatcher from 'src/host/dispatchers/event_dispatcher';
+import eventActions from 'src/host/actions/event_actions';
+import simpleXDM from 'simple-xdm/host';
+
+describe('Host API', function() {
+
+  it('onIframeEstablished binds', function() {
+    var spy = jasmine.createSpy('spy');
+    HostApi.onIframeEstablished(spy);
+    EventDispatcher.dispatch('after:iframe-bridge-established', {$el: AJS.$('<div />'), extension:{options:{}}});
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('onIframeUnload binds', function() {
+    var spy = jasmine.createSpy('spy');
+    HostApi.onIframeUnload(spy);
+    EventDispatcher.dispatch('after:iframe-unload', {extension:{}});
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('onEventDispatched binds', function(){
+    var spy = jasmine.createSpy('spy');
+    HostApi.onPublicEventDispatched(spy);
+    eventActions.broadcastPublic('a', {}, {
+      addon_key: 'abc',
+      key: '123'
+    });
+    expect(spy).toHaveBeenCalled();
+    HostApi.offPublicEventDispatched(spy);
+  });
+
+  it('broadcastPublic sanitises extension options for XDM including jwt tokens', function(){
+    spyOn(simpleXDM, 'dispatch');
+
+    var spy = jasmine.createSpy('spy');
+    HostApi.onPublicEventDispatched(spy);
+    const type = 'a';
+    const event = {};
+    const sanitisedExtension = {
+      addon_key: 'abc',
+      key: '123',
+      options: { }
+    };
+    const unsanitisedExtension = Object.assign({}, sanitisedExtension, {
+      options: {
+        some_func: function () {},
+        url: 'https://some.host.com/?jwt=secret',
+        contextJwt: 'secretJwtToken'
+      }
+    });
+    const sender = {
+      addonKey: sanitisedExtension.addon_key,
+      key: sanitisedExtension.key,
+      options: sanitisedExtension.options
+    };
+    eventActions.broadcastPublic(type, event, unsanitisedExtension);
+    expect(spy).toHaveBeenCalledWith({
+      event,
+      extension: unsanitisedExtension,
+      type
+    });
+    expect(simpleXDM.dispatch).toHaveBeenCalledWith(type, {}, {
+      event,
+      sender
+    });
+    HostApi.offPublicEventDispatched(spy);
+  });
+
+  it('offEventDispatched unbinds', function(){
+    var spy = jasmine.createSpy('anotherspy');
+    HostApi.onPublicEventDispatched(spy);
+    HostApi.offPublicEventDispatched(spy);
+    eventActions.broadcastPublic('a', {}, {
+      addon_key: 'abc',
+      key: '123'
+    });
+    expect(spy).not.toHaveBeenCalled();
+  });
+
+  it('setJwtClockSkew sets the clockSkew', function(done){
+    var skew = 12345;
+    EventDispatcher.once('jwt-skew-set', (data) => {
+      expect(data.skew).toEqual(skew);
+      done();
+    });
+    HostApi.setJwtClockSkew(skew);
+  });
+
+  it('getContentResolver gets the content resolver', function(){
+    var testContentResolver = function(params){};
+    HostApi.registerContentResolver.resolveByExtension(testContentResolver);
+    expect(HostApi.getContentResolver()).toEqual(testContentResolver);
+  });
+
+  it('dialog.create uses dialog module options', function(done){
+    var extension = {
+      addon_key: 'abc',
+      key: 'abc123'
+    };
+    var dialogOptions = {
+      height: '200px',
+      title: 'overriden'
+    };
+    var dialogBeanOptions = {
+      width: '123px',
+      title: 'override me'
+    };
+    // mock dialogBean options being placed in the product
+    window._AP = {
+      dialogModules: {
+        abc: {
+          abc123: {
+            options: dialogBeanOptions
+          }
+        }
+      }
+    };
+
+    EventDispatcher.registerOnce('after:dialog-extension-open', (e) => {
+      expect(e.extension).toEqual({
+        addon_key: extension.addon_key,
+        key: extension.key
+      });
+      expect(e.options).toEqual({
+        height: dialogOptions.height,
+        width: dialogBeanOptions.width,
+        title: dialogOptions.title
+      });
+      done();
+    });
+
+    HostApi.dialog.create(extension, dialogOptions);
+  });
+
+  it('Registered click handler gets called with reference to iframe', () => {
+    const target_spec = {
+      addon_key: 'some-key',
+      key: 'module-key'
+    };
+    const reg = {
+      extension: target_spec,
+      extension_id: `${target_spec.addon_key}__${target_spec.key}`
+    };
+    const iframe = document.createElement('iframe');
+    const callback = jasmine.createSpy('callback');
+
+    iframe.id = reg.extension_id;
+    document.body.appendChild(iframe);
+    HostApi.onFrameClick(callback);
+    simpleXDM._xdm._handleAddonClick(null, reg);
+    expect(callback).toHaveBeenCalled();
+    expect(callback.calls.mostRecent().args[0]).toEqual(iframe);
+    document.body.removeChild(iframe);
+  });
+
+  it('destroy removes the extension', () => {
+    const spec = {
+      addon_key: 'my-addon-key',
+      key: 'somekey',
+      url: 'http://www.example.com'
+    };
+    let iframe = HostApi.create(spec);
+    let extensions = HostApi.getExtensions(spec);
+    expect(extensions.length).toEqual(1);
+    HostApi.destroy(extensions[0].extension_id);
+    expect(HostApi.getExtensions(spec).length).toEqual(0);
+  });
+
+  it('closes a dialog using the provider', () => {
+    const spec = {
+      addon_key: 'abc123-addon-key',
+      key: 'some-key',
+      url: 'http://www.example.com'
+    };
+    const closeSpy = jasmine.createSpy('spy');
+    const frameworkAdaptor = {
+      getProviderByModuleName: function(){
+        return {
+          close: closeSpy,
+          isActiveDialog: jasmine.createSpy('spy').and.returnValue(true)
+        };
+      }
+    };
+    HostApi.setFrameworkAdaptor(frameworkAdaptor);
+    HostApi.dialog.close(spec.addon_key);
+    expect(closeSpy).toHaveBeenCalled();
+  });
+
+  it('can tell if module is defined', () => {
+    const moduleName = 'foo';
+    simpleXDM.defineModule(moduleName, {});
+    expect(HostApi.isModuleDefined(moduleName)).toBe(true);
+  });
+
+  it('onIframeTimeout binds', function() {
+    var spy = jasmine.createSpy('spy');
+    HostApi.onIframeTimeout(spy);
+    EventDispatcher.dispatch('after:iframe-bridge-timeout', {extension:{options:{}}});
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('onIframePerformanceTelemetry binds', function() {
+    var spy = jasmine.createSpy('spy');
+    HostApi.onIframePerformanceTelemetry(spy);
+    EventDispatcher.dispatch('after:analytics-iframe-performance', {extension:{options:{}}, metrics: {}});
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('onIframeVisible binds', function() {
+    var spy = jasmine.createSpy('spy');
+    HostApi.onIframeVisible(spy);
+    EventDispatcher.dispatch('iframe-visible', {options:{}});
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('exports targetSpecNoDialogs', function() {
+    expect(typeof HostApi.targetSpecNoDialogs).toBe('function');
+  });
+});

package/spec/tests/iframe-create_spec.js

@@ -0,0 +1,43 @@
+import IframeCreate from 'src/host/iframe-create';
+
+describe('Iframe Create', () => {
+  var extensionConfig = {
+    addon_key: 'addon-key',
+    key: 'module-key',
+    url: '/iframe-content.html',
+    options: {
+      isGeneral: true
+    }, //options to send to the iframe
+    data: { //data to stay on the host side
+      pageType: 'general',
+      productCtx: '{}',
+      uid: 'someUserId'
+    }
+  };
+
+
+  it('returns an iframe container node', () => {
+    var container = IframeCreate(extensionConfig);
+    expect(container.length).toEqual(1);
+    expect(container.hasClass('ap-iframe-container')).toBe(true);
+    expect(container.find('iframe').length).toEqual(1);
+  });
+
+  describe('iframe has attribute', () => {
+    var iframe = IframeCreate(extensionConfig).find('iframe');
+    it('src', () => {
+      expect(iframe.attr('src')).toContain(extensionConfig.url);
+    });
+
+    it('id', () => {
+      expect(iframe.attr('id')).toContain(extensionConfig.addon_key);
+      expect(iframe.attr('id')).toContain(extensionConfig.key);
+    });
+
+    it('name', () => {
+      expect(iframe.attr('name')).toContain('{}');
+    });
+
+  });
+
+});

package/spec/tests/iframe_container_spec.js

@@ -0,0 +1,19 @@
+import IframeContainerComponent from 'src/host/components/iframe_container';
+
+describe('Iframe container component', () => {
+
+  describe('createExtension', () => {
+
+    it('returns a container', () => {
+      var extension = {
+        addon_key: 'some-addon-key',
+        key: 'some-module-key',
+        url: 'https://www.example.com'
+      };
+      var createdExtension = IframeContainerComponent.createExtension(extension);
+      expect(createdExtension.hasClass('ap-iframe-container')).toBe(true);
+    });
+  });
+
+
+});