@atlassian/atlassian-connect-js 5.3.190

package/spec/fixtures/base_dialog_component_tests.js

@@ -0,0 +1,180 @@
+function unit(str){
+  return (str.search(/px/) > 0) ? 'px' : '%';
+}
+
+function size($el, options){
+  if(options.size){
+    expect($el.hasClass('aui-dialog2-' + options.size), 'size is set').toEqual(true);
+  } else if(options.width){
+    expect($el.width() + unit(options.width)).toEqual(options.width);
+    expect($el.height() + unit(options.height)).toEqual(options.height);
+  }
+}
+
+function chrome($el, options){
+  expect($el.hasClass('aui-dialog2')).toEqual(true);
+  expect($el.hasClass('ap-aui-dialog2')).toEqual(true);
+  expect($el.hasClass('aui-layer')).toEqual(true);
+  header($el, options);
+  hint($el, options);
+  footer($el, options);
+  buttons($el, options);
+  customButtons($el, options);
+  size($el, options);
+}
+
+function chromeless($el, options){
+  expect($el.hasClass('aui-dialog2')).toEqual(true);
+  expect($el.hasClass('ap-aui-dialog2')).toEqual(true);
+  expect($el.hasClass('aui-layer')).toEqual(true);
+  expect($el.hasClass('aui-dialog2-chromeless')).toEqual(true);
+  size($el, options);
+}
+
+function fullscreen($el, options){
+  expect($el.hasClass('aui-dialog2')).toEqual(true);
+  expect($el.hasClass('ap-aui-dialog2')).toEqual(true);
+  expect($el.hasClass('aui-layer')).toEqual(true);
+  expect($el.hasClass('aui-dialog2-chromeless')).toEqual(false);
+  expect($el.hasClass('aui-dialog2-fullscreen')).toEqual(true);
+  expect($el.hasClass('ap-header-controls')).toEqual(true);
+  expect($el.hasClass('aui-dialog2-maximum')).toEqual(true);
+  expect($el.height()).toEqual($(window).height());
+  expect($el.width()).toEqual($(window).width());
+  fullscreenHeader($el, options);
+  hint($el, options);
+  footer($el, options);
+  fullscreenButtons($el, options);
+  customButtons($el, options);
+}
+
+function fullscreenHeader($el, options){
+  expect($el.find('.header-title').text()).toEqual(options.header.value);
+}
+
+function fullscreenButtons($el, options){
+  var $controlPanel = $el.find('.header-control-panel');
+  expect($controlPanel.length).toEqual(1);
+  // 4 buttons, 2 default + 2 user custom buttons
+  expect($controlPanel.find('button').length).toEqual(4);
+  var $primary = $controlPanel.find('.aui-button-primary');
+  var $cancel = $controlPanel.find('.aui-button-link');
+  expect($primary.length).toEqual(1);
+  expect($primary.text()).toEqual(options.submitText);
+  expect($cancel.length).toEqual(1);
+  expect($cancel.text()).toEqual(options.cancelText);
+}
+
+function customButtons($el, options) {
+  function buttonByIdentifier($dialog, identifier) {
+    return $el.find('.aui-button-secondary').filter(function(index, button){
+      return $(button).data('identifier') === identifier;
+    });
+  }
+  if(options.buttons) {
+    options.buttons.forEach(function(button) {
+      var $btn = buttonByIdentifier($el, button.identifier);
+      expect($btn.length).toEqual(1);
+      expect($btn.hasClass('ap-dialog-custom-button')).toEqual(true);
+      expect($btn.hasClass('aui-button-secondary')).toEqual(true);
+      expect($btn.text()).toEqual(button.text);
+    });
+  }
+}
+
+
+function header($el, options){
+  expect($el.find('.aui-dialog2-header-main').text()).toEqual(options.header.value);
+}
+
+function hint($el, options){
+  expect($el.find('.aui-dialog2-footer-hint').text()).toEqual(options.hint);
+}
+
+function footer($el, options){
+  expect($el.find('.aui-dialog2-footer').length).toEqual(1);
+}
+
+function buttons($el, options){
+  // 2 default + 2 custom buttons specified in the options
+  expect($el.find('button').length).toEqual(4);
+  var $primary = $el.find('.aui-dialog2-footer .aui-button-primary');
+  var $cancel = $el.find('.aui-dialog2-footer .aui-button-link');
+  expect($primary.length).toEqual(1);
+  expect($primary.text()).toEqual(options.submitText);
+  expect($cancel.length).toEqual(1);
+  expect($cancel.text()).toEqual(options.cancelText);
+}
+
+module.exports = {
+  getChromeOptions: function(){
+    return {
+      chrome: true,
+      header: {
+        value: 'a header'
+      },
+      hint: 'a hint',
+      size: 'large',
+      submitText: 'my submit text',
+      cancelText: 'some cancel text',
+      buttons: [
+        {
+          text: 'some button text',
+          identifier: 'abc123'
+        },
+        {
+          text: 'second button text',
+          identifier: 'zxy321'
+        }
+      ]
+    };
+  },
+  getChromelessOptions: function(){
+    return {
+      chrome: false,
+      size: 'small'
+    };
+  },
+  getFullscreenOptions: function(){
+    return {
+      size: 'fullscreen',
+      header: {
+        value: 'a fullscreen header'
+      },
+      width: 1000,
+      height: 321,
+      submitText: 'a submit text',
+      cancelText: 'a cancel text',
+      hint: 'fullscreen hint',
+      buttons: [
+        {
+          text: 'first btn text',
+          identifier: 'ab12'
+        },
+        {
+          text: 'second btn text',
+          identifier: 'zx32'
+        }
+      ]
+
+    };
+  },
+  testFullScreen: function(options, $el){
+    if(!$el){
+      $el = $('.aui-dialog2');
+    }
+    return fullscreen($el, options);
+  },
+  testChrome: function(options, $el){
+    if(!$el){
+      $el = $('.aui-dialog2');
+    }
+    return chrome($el, options);
+  },
+  testChromeless: function(options, $el){
+    if(!$el){
+      $el = $('.aui-dialog2');
+    }
+    return chromeless($el, options);
+  },
+};

package/spec/mocks/mock_feature_flag.js

@@ -0,0 +1,23 @@
+/**
+ * @param name {string}
+ * @param value {boolean}
+ */
+export function mockFeatureFlag(name, value) {
+  window.featureFlags = window.featureFlags || {}
+  window.featureFlags[name] = { value }
+}
+export function resetFeatureFlags() {
+  window.featureFlags = {}
+}
+
+let mockIframeFlags = {}
+export function mockIframeFeatureFlag(name, value) {
+  mockIframeFlags[name] = value
+  window.AP = window.AP || {}
+  window.AP._featureFlag = window.AP._featureFlag || {}
+  window.AP._featureFlag.getBooleanFeatureFlag = window.AP._featureFlag.getBooleanFeatureFlag || function() {}
+  window.AP._featureFlag.getBooleanFeatureFlag = async (flagName) => mockIframeFlags[flagName]
+}
+export function resetIframeFeatureFlags() {
+  mockIframeFlags = {}
+}

package/spec/tests/amd_spec.js

@@ -0,0 +1,122 @@
+import AP from 'simple-xdm/combined';
+import AMD from 'src/plugin/amd';
+
+var testFunctionSpy = jasmine.createSpy('testFunction').and.callFake(() => 1337);
+var otherThingSpy = jasmine.createSpy('otherThing').and.callFake((thing) => thing);
+var newThingSpy = jasmine.createSpy('newThing').and.callFake((thing) => thing);
+
+describe('AMD', () => {
+  beforeEach(() => {
+    AP._hostModules = {
+      existingModule: {
+        testFunction: testFunctionSpy
+      },
+      otherThing: otherThingSpy
+    };
+
+    AP.define = AMD.define;
+    AP.require = AMD.require;
+
+    AP._hostModules.newThing = {
+      newHostFunction: newThingSpy
+    };
+  });
+
+  afterEach(() => {
+    window.AP = null;
+  });
+
+  describe('define', () => {
+    it('creates a module', () => {
+      var bonusFunctionSpy = jasmine.createSpy('bonusFunction').and.callFake(() => '+1');
+      AP.define('myObject', () => {
+        return {
+          bonusFunction: bonusFunctionSpy
+        }
+      });
+      AP.require('myObject', function(myObject) {
+        expect(myObject).not.toBeUndefined();
+        expect(myObject.hasOwnProperty('bonusFunction')).toBe(true);
+        expect(myObject.bonusFunction()).toEqual('+1');
+        expect(bonusFunctionSpy).toHaveBeenCalled();
+      });
+    });
+
+    it('create module with a dependency', () => {
+      AP.define('newThing', ['existingModule'], (existingModule) => {
+        expect(existingModule).not.toBeUndefined();
+        expect(existingModule.hasOwnProperty('testFunction')).toBe(true);
+        existingModule.testFunction();
+        expect(testFunctionSpy).toHaveBeenCalled();
+      });
+    });
+
+    it('create module with multiple dependencies', () => {
+      AP.define('newThing', ['existingModule', 'otherThing'], (existingModule, otherThing) => {
+        var testVal = Date.now();
+        expect(existingModule).not.toBeUndefined();
+        expect(existingModule.hasOwnProperty('testFunction')).toBe(true);
+        expect(otherThing).not.toBeUndefined();
+        expect(existingModule.testFunction()).toEqual(1337);
+        expect(otherThing(testVal)).toEqual(testVal);
+        expect(testFunctionSpy).toHaveBeenCalled();
+        expect(otherThingSpy).toHaveBeenCalledWith(testVal);
+      });
+    });
+
+    it('overwrite an existing module', () => {
+      var bonusFunctionSpy = jasmine.createSpy('bonusFunction').and.callFake(() => '+1');
+      AP.define('existingModule', () => {
+        return {
+          bonusFunction: bonusFunctionSpy
+        }
+      });
+
+      AP.require('existingModule', (existingModule) => {
+        expect(existingModule.hasOwnProperty('bonusFunction')).toBe(true);
+        expect(existingModule.bonusFunction()).toEqual('+1');
+        expect(bonusFunctionSpy).toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('require', () => {
+    it('existing host modules', () => {
+      AP.require('existingModule', (existingModule) => {
+        expect(existingModule).not.toBeUndefined();
+        expect(existingModule.hasOwnProperty('testFunction')).toBe(true);
+        expect(existingModule.testFunction()).toEqual(1337);
+        expect(testFunctionSpy).toHaveBeenCalled();
+      });
+    });
+
+    it('multiple modules', () => {
+      AP.require(['existingModule', 'otherThing'], (existingModule, otherThing) => {
+        var testVal = Date.now();
+        expect(existingModule).not.toBeUndefined();
+        expect(existingModule.hasOwnProperty('testFunction')).toBe(true);
+        expect(existingModule.testFunction()).toEqual(1337);
+        expect(otherThing).not.toBeUndefined();
+        expect(otherThing(testVal)).toEqual(testVal);
+        expect(testFunctionSpy).toHaveBeenCalled();
+        expect(otherThingSpy).toHaveBeenCalledWith(testVal);
+      });
+    });
+
+    it('undefined module', () => {
+      AP.require('nonExistentModule', (notAThing) => {
+        expect(notAThing()).toBeUndefined();
+      });
+    });
+
+    it('new host module after initialisation', () => {
+      AP.require('newThing', (newThing) => {
+        var testVal = Date.now();
+        expect(newThing).not.toBeUndefined();
+        expect(newThing.hasOwnProperty('newHostFunction')).toBe(true);
+        expect(newThing.newHostFunction(testVal)).toEqual(testVal);
+        expect(newThingSpy).toHaveBeenCalledWith(testVal);
+      });
+    })
+  });
+});