@atlassian/atlassian-connect-js 5.3.190

package/spec/tests/analytics_dispatcher_spec.js

@@ -0,0 +1,429 @@
+import AnalyticsDispatcher from 'src/host/dispatchers/analytics_dispatcher';
+import IframeActions from 'src/host/actions/iframe_actions';
+import LoadingIndicatorActions from 'src/host/actions/loading_indicator_actions';
+import HostApi from '../../src/host/host-api';
+import { observeIframeRemoval } from 'src/host/utils/removal-observer';
+import getBooleanFeatureFlag from '../../src/host/utils/feature-flag';
+
+const extension = {
+  id: 'xxxewjkd',
+  addon_key: 'some-addon-key',
+  key: 'some-module-key'
+};
+
+
+
+describe('Analytics Dispatcher', () => {
+  beforeEach(() => {
+    window.requestIdleCallback = (callback) => setTimeout(callback);
+  });
+
+  it('trackLoadingStarted stores the time', () => {
+    expect(AnalyticsDispatcher._addons).toEqual({});
+    AnalyticsDispatcher.trackLoadingStarted(extension);
+    expect(AnalyticsDispatcher._addons[extension.id].startLoading).toEqual(jasmine.any(Number));
+  });
+
+  it('should consistently sample load events', () => {
+    spyOn(AnalyticsDispatcher, '_shouldSampleEvent').and.returnValue(true);
+    expect(AnalyticsDispatcher._shouldSampleLoadEvent({ id: '1234' })).toBe(true);
+
+    AnalyticsDispatcher._shouldSampleEvent.and.returnValue(false);
+    // Remember the result for the same ID
+    expect(AnalyticsDispatcher._shouldSampleLoadEvent({ id: '1234' })).toBe(true);
+    // A new ID should return false
+    expect(AnalyticsDispatcher._shouldSampleLoadEvent({ id: '5678' })).toBe(false);
+  })
+
+  it('trackUseOfDeprecatedMethod triggers a gasV3 analytics call', () => {
+    spyOn(AnalyticsDispatcher, '_trackAndForwardGasV3');
+    var methodUsed = 'someDeprecatedMethodName';
+    AnalyticsDispatcher.trackGasV3UseOfDeprecatedMethod(methodUsed, extension);
+    expect(AnalyticsDispatcher._trackAndForwardGasV3).toHaveBeenCalledWith('operational', {
+      action: 'deprecatedMethod',
+      actionSubject: 'connectAddon',
+      actionSubjectId: extension.addon_key,
+      attributes: {
+        methodUsed: methodUsed,
+        moduleKey: extension.key
+      },
+      source: extension.addon_key
+    });
+  });
+
+  it('dispatch/trackExternal triggers a gasV3 analytics call', () => {
+    spyOn(AnalyticsDispatcher, '_trackAndForwardGasV3');
+    var eventName = 'event.name';
+    var eventValue = {
+      addonKey: extension.addon_key,
+      moduleKey: extension.key,
+      value: 'something'
+    };
+    AnalyticsDispatcher.dispatch(eventName, eventValue);
+    expect(AnalyticsDispatcher._trackAndForwardGasV3).toHaveBeenCalledWith('operational', {
+      action: 'externalEvent',
+      actionSubject: 'connectAddon',
+      actionSubjectId: eventName,
+      attributes: {
+        eventName,
+        addonKey: extension.addon_key,
+        moduleKey: extension.key,
+        value: 'something'
+      },
+      source: 'connectAddon'
+    });
+
+  });
+
+  it('removes the timeout when the entry is removed from addon store', () => {
+    AnalyticsDispatcher.trackLoadingStarted(extension);
+    expect(AnalyticsDispatcher._addons[extension.id]).toBeDefined();
+    let TimeoutId = AnalyticsDispatcher._addons[extension.id];
+    spyOn(window, 'clearTimeout');
+
+    AnalyticsDispatcher._resetAnalyticsDueToUnreliable(extension.id);
+    expect(AnalyticsDispatcher._addons[extension.id]).toBeUndefined();
+    expect(window.clearTimeout).toHaveBeenCalledWith(TimeoutId);
+  });
+
+  it('trackIframePerformanceMetrics triggers _analytics.trackIframePerformanceMetrics', () => {
+    spyOn(AnalyticsDispatcher, '_shouldSampleEvent').and.returnValue(true);
+    spyOn(AnalyticsDispatcher, '_trackGasV3');
+    var metrics = {
+      domainLookupTime: 111,
+      connectionTime: 2222,
+      decodedBodySize: 333,
+      domContentLoadedTime: 444,
+      fetchTime: 555
+    };
+    AnalyticsDispatcher.trackIframePerformance(metrics, Object.assign({}, extension, {options: {
+      pearApp: 'true',
+      moduleLocation: 'some-module-location',
+      moduleType: 'some-module-type'
+    }}));
+    expect(AnalyticsDispatcher._trackGasV3).toHaveBeenCalled();
+    expect(AnalyticsDispatcher._trackGasV3).toHaveBeenCalledWith('operational', {
+      source: extension['addon_key'],
+      action: 'iframeRendered',
+      actionSubject: 'connectAddon',
+      actionSubjectId: extension['addon_key'],
+      attributes: {
+        key: extension['key'],
+        pearApp: true,
+        domainLookupTime: metrics.domainLookupTime,
+        connectionTime: metrics.connectionTime,
+        decodedBodySize: metrics.decodedBodySize,
+        domContentLoadedTime: metrics.domContentLoadedTime,
+        fetchTime: metrics.fetchTime,
+        moduleLocation: 'some-module-location',
+        moduleType: 'some-module-type',
+        iframeIsCacheable: false
+      }
+    });
+  });
+
+  it('on iframe viewed trigger a gasv3 analytics call', () => {
+    spyOn(AnalyticsDispatcher, '_shouldSampleEvent').and.returnValue(true);
+    spyOn(AnalyticsDispatcher, '_trackGasV3');
+    const extension = {
+      addon_key: 'some-addon-key',
+      key: 'some-module-key',
+      options: {
+        moduleType: 'some-module-type',
+        pearApp: 'true',
+        moduleLocation: 'some-module-location'
+      },
+      id: 'some-addon-key__some-module-key_1y28nd',
+      startLoading: Date.now()
+    };
+    AnalyticsDispatcher.trackGasV3Visible(extension);
+
+    expect(AnalyticsDispatcher._trackGasV3).toHaveBeenCalledWith('operational', {
+      source: 'some-addon-key',
+      action: 'iframeViewed',
+      actionSubject: 'connectAddon',
+      actionSubjectId: 'some-addon-key',
+      attributes: {
+        iframeIsCacheable: false,
+        moduleType: 'some-module-type',
+        moduleKey: 'some-module-key',
+        moduleLocation: 'some-module-location',
+        pearApp: true
+      }
+    });
+  });
+
+  it('on method invoked trigger a gasv3 analytics call', () => {
+    spyOn(AnalyticsDispatcher, '_shouldSampleEvent').and.returnValue(true);
+    spyOn(AnalyticsDispatcher, '_trackAndForwardGasV3');
+    const extension = {
+      addon_key: 'some-addon-key',
+      key: 'some-module-key',
+      options: {
+        moduleType: 'some-module-type',
+        moduleLocation: 'some-module-location',
+        pearApp: 'false',
+      },
+      id: 'some-addon-key__some-module-key_1y28nd',
+    };
+    const module = 'foo';
+    const fn = 'bar';
+
+    const contextFn = () => {};
+    contextFn._context = {};
+
+    const args = [
+      undefined, null, 'some string', 1234, {}, [], () => {},
+      // Undefined and the context function should be ignored, only at the end
+      undefined, contextFn
+    ]
+    AnalyticsDispatcher.trackGasV3InvokeMethod(extension, module, fn, args);
+
+    expect(AnalyticsDispatcher._trackAndForwardGasV3).toHaveBeenCalledWith(
+      'operational',
+      {
+        action: 'invokeMethod',
+        actionSubject: 'connectAddon',
+        actionSubjectId: 'some-addon-key',
+        attributes: {
+          argCount: 7,
+          argTypes: ['undefined', 'null', 'string', 'number', 'object', 'array', 'function'],
+          method: 'bar',
+          module: 'foo',
+          moduleKey: 'some-module-key',
+          moduleType: 'some-module-type',
+          moduleLocation: 'some-module-location',
+          pearApp: false,
+        },
+        source: 'some-addon-key',
+      }
+    );
+  });
+
+  it('should always trigger a gasv3 analytics call for allowlisted methods', () => {
+    // Should still be called even with sampling returning false
+    spyOn(AnalyticsDispatcher, '_shouldSampleEvent').and.returnValue(false);
+    spyOn(AnalyticsDispatcher, '_trackAndForwardGasV3');
+    const extension = {
+      addon_key: 'some-addon-key',
+      key: 'some-module-key',
+      options: {
+        moduleType: 'some-module-type',
+        moduleLocation: 'some-module-location',
+        pearApp: 'false',
+      },
+      id: 'some-addon-key__some-module-key_1y28nd',
+    };
+    const module = 'foo';
+    const fn = 'saveMacro';
+
+    AnalyticsDispatcher.trackGasV3InvokeMethod(extension, module, fn);
+
+    expect(AnalyticsDispatcher._trackAndForwardGasV3).toHaveBeenCalledWith(
+      'operational',
+      {
+        action: 'invokeMethod',
+        actionSubject: 'connectAddon',
+        actionSubjectId: 'some-addon-key',
+        attributes: {
+          argCount: 0,
+          argTypes: [],
+          method: 'saveMacro',
+          module: 'foo',
+          moduleKey: 'some-module-key',
+          moduleType: 'some-module-type',
+          moduleLocation: 'some-module-location',
+          pearApp: false,
+        },
+        source: 'some-addon-key',
+      }
+    );
+  });
+
+  it('on iframe-bridge-established trigger a gasv3 analytics call', () => {
+    spyOn(AnalyticsDispatcher, '_shouldSampleEvent').and.returnValue(true);
+    spyOn(AnalyticsDispatcher, '_trackGasV3');
+    const extension = {
+      addon_key: 'some-addon-key',
+      key: 'some-module-key',
+      options: {
+        moduleType: 'some-module-type',
+        pearApp: 'true',
+        moduleLocation: 'some-module-location',
+        noDom: true,
+      },
+      id: 'some-addon-key__some-module-key_1y28nd',
+      startLoading: Date.now()
+    };
+    AnalyticsDispatcher._addons[extension.id] = extension;
+
+    IframeActions.notifyBridgeEstablished(document.createElement('div'), extension);
+
+    expect(AnalyticsDispatcher._trackGasV3).toHaveBeenCalledWith('operational', {
+      source: 'some-addon-key',
+      action: 'iframeLoaded',
+      actionSubject: 'connectAddon',
+      actionSubjectId: 'some-addon-key',
+      attributes: {
+        iframeIsCacheable: false,
+        iframeLoadMillis: jasmine.any(Number),
+        iframeLoadBucket: jasmine.any(Number),
+        moduleType: 'some-module-type',
+        moduleKey: 'some-module-key',
+        moduleLocation: 'some-module-location',
+        pearApp: true
+      }
+    });
+  });
+
+  it('on iframe-bridge-timeout trigger a gasv3 analytics call', () => {
+    spyOn(AnalyticsDispatcher, '_shouldSampleEvent').and.returnValue(true);
+    spyOn(AnalyticsDispatcher, '_trackGasV3');
+    const extension = {
+      addon_key: 'some-addon-key',
+      key: 'some-module-key',
+      options: {
+        moduleType: 'some-module-type',
+        pearApp: 'true',
+        moduleLocation: 'some-module-location',
+        noDom: true
+      },
+      id: 'some-addon-key__some-module-key_1d28nd'
+    };
+
+    LoadingIndicatorActions.timeout(document.createElement('div'), extension);
+
+    expect(AnalyticsDispatcher._trackGasV3).toHaveBeenCalledWith('operational', {
+      source: 'some-addon-key',
+      action: 'iframeTimeout',
+      actionSubject: 'connectAddon',
+      actionSubjectId: 'some-addon-key',
+      attributes: {
+        iframeIsCacheable: false,
+        moduleType: 'some-module-type',
+        moduleKey: 'some-module-key',
+        moduleLocation: 'some-module-location',
+        pearApp: true,
+        connectedStatus: 'true'
+      }
+    });
+  });
+
+  it('web-vitals analytics call should be triggered', () => {
+    spyOn(AnalyticsDispatcher, '_shouldSampleEvent').and.returnValue(true);
+    spyOn(AnalyticsDispatcher, '_trackAndForwardGasV3');
+    const extension = {
+      addon_key: 'some-addon-key',
+      key: 'some-module-key',
+      options: {
+        moduleType: 'some-module-type',
+        pearApp: 'true',
+        moduleLocation: 'some-module-location'
+      },
+    }
+
+    AnalyticsDispatcher.trackGasV3WebVitals({
+      'metric:cls': 0.1,
+      'metric:fcp': 1000,
+      'metric:lcp': 2000,
+      'metric:ttfb': 3000,
+    }, extension);
+
+    expect(AnalyticsDispatcher._trackAndForwardGasV3).toHaveBeenCalledWith('operational', {
+      source: 'some-addon-key',
+      action: 'webVitals',
+      actionSubject: 'connectAddon',
+      actionSubjectId: 'some-addon-key',
+      attributes: {
+        'metric:cls': 0.1,
+        'metric:fcp': 1000,
+        'metric:lcp': 2000,
+        'metric:ttfb': 3000,
+        iframeIsCacheable: false,
+        moduleType: 'some-module-type',
+        key: 'some-module-key',
+        moduleLocation: 'some-module-location',
+        pearApp: true
+      }});
+  })
+
+  it('should trigger analytics when statsig client is not initialized', () => {
+    spyOn(AnalyticsDispatcher, '_trackAndForwardGasV3');
+    getBooleanFeatureFlag('some-flag', true);
+    expect(AnalyticsDispatcher._trackAndForwardGasV3).toHaveBeenCalledWith('operational', {
+      action: 'returned',
+      actionSubject: 'defaultFalseFeatureFlag',
+      actionSubjectId: 'some-flag',
+      attributes: {
+        featureFlag: 'some-flag',
+      },
+      source: 'Host',
+    });
+  });
+});
+
+describe('observeIframes', () => {
+  let observer;
+  beforeEach(() => {
+    // Mocking HostApi.destroy method
+    spyOn(HostApi, 'destroy');
+
+    // Pass the mockHostApi to the observeIframes function
+    observer = observeIframeRemoval();
+  });
+
+  afterEach(() => {
+    // Clean up after each test
+    observer.disconnect();
+  });
+
+  it('should call HostApi.destroy when an iframe is removed', (done) => {
+    // Create a test iframe with an ID and append it to the document
+    const iframe = document.createElement('iframe');
+    iframe.id = 'test-iframe';
+    document.body.appendChild(iframe);
+
+    // Remove the iframe and check if HostApi.destroy is called
+    document.body.removeChild(iframe);
+
+    // MutationObserver works asynchronously, so we need to wait for it
+    setTimeout(() => {
+      expect(HostApi.destroy).toHaveBeenCalledWith('test-iframe');
+      done();
+    }, 50);
+  });
+
+  it('should call HostApi.destroy for iframes within a removed node', (done) => {
+    // Create a div containing an iframe
+    const container = document.createElement('div');
+    const nestedIframe = document.createElement('iframe');
+    nestedIframe.id = 'nested-iframe';
+    container.appendChild(nestedIframe);
+    document.body.appendChild(container);
+
+    // Remove the container div
+    document.body.removeChild(container);
+
+    // MutationObserver works asynchronously, so we need to wait for it
+    setTimeout(() => {
+      expect(HostApi.destroy).toHaveBeenCalledWith('nested-iframe');
+      done();
+    }, 50);
+  });
+
+  it('should not call HostApi.destroy if a non-iframe node is removed', (done) => {
+    // Create a non-iframe element and append it to the document
+    const div = document.createElement('div');
+    div.id = 'test-div';
+    document.body.appendChild(div);
+
+    // Remove the non-iframe element
+    document.body.removeChild(div);
+
+    // MutationObserver works asynchronously, so we need to wait to ensure no calls were made
+    setTimeout(() => {
+      expect(HostApi.destroy).not.toHaveBeenCalled();
+      done();
+    }, 50);
+  });
+});

package/spec/tests/analytics_performance_spec.js

@@ -0,0 +1,41 @@
+import AP from 'simple-xdm/combined';
+import analytics from 'src/plugin/analytics';
+
+describe('Plugin Performance Analytics', () => {
+  beforeEach(() => {
+    AP._analytics = {
+      trackIframePerformanceMetrics: jasmine.createSpy('testFunction'),
+      trackWebVitals: jasmine.createSpy('trackWebVitals')
+    };
+  });
+
+  afterEach(() => {
+    window.AP = null;
+  });
+
+  it('sends performance metrics', () => {
+    analytics.sendMetrics();
+    expect(AP._analytics.trackIframePerformanceMetrics).toHaveBeenCalled();
+    const firstCallArg = AP._analytics.trackIframePerformanceMetrics.calls.first().args[0];
+    // We skip these assertions for the p2 plugin integration test version of chrome used in webdriver tests because the API does not exist in that version.
+    // We also skip these in Safari because Safari does not support this API.
+    if(navigator.appVersion.indexOf('Chrome/48.') === -1 && navigator.appVersion.indexOf('Safari') === -1) {
+      expect(firstCallArg.connectionTime).toEqual(jasmine.any(Number));
+      expect(firstCallArg.decodedBodySize).toEqual(jasmine.any(Number));
+      expect(firstCallArg.domContentLoadedTime).toEqual(jasmine.any(Number));
+      expect(firstCallArg.domainLookupTime).toEqual(jasmine.any(Number));
+      expect(firstCallArg.fetchTime).toEqual(jasmine.any(Number));
+    }
+  });
+
+  it('sends web vitals', (done) => {
+    analytics.setupWebVitals(1000);
+    setTimeout(() => {
+      expect(AP._analytics.trackWebVitals).toHaveBeenCalled();
+      const firstCallArg = AP._analytics.trackWebVitals.calls.first().args[0];
+      expect(Object.keys(firstCallArg).length).toBeGreaterThan(0);
+      expect(Object.values(firstCallArg).every(value => typeof value === 'number')).toBe(true);
+      done()
+    }, 1001);
+  })
+});

package/spec/tests/button_spec.js

@@ -0,0 +1,143 @@
+import ButtonComponent from 'src/host/components/button';
+import EventDispatcher from 'src/host/dispatchers/event_dispatcher';
+
+describe('Button component', () => {
+  afterEach(() => {
+    $('.aui-button').remove();
+  });
+  describe('render', () => {
+
+    it('renders a button', () => {
+      var $button = ButtonComponent.render();
+      expect($button[0].nodeName).toEqual('BUTTON');
+      expect($button.hasClass(ButtonComponent.AP_BUTTON_CLASS)).toBe(true);
+      expect($button.attr('id')).toMatch(/ap\-button\-[0-9]{1}/);
+      expect($button.attr('aria-disabled')).toEqual('false');
+    });
+
+    it('with an id', () => {
+      var id = 'someid';
+      var $button = ButtonComponent.render({
+        id: id
+      });
+      expect($button.attr('id')).toEqual(id);
+    });
+
+    it('with text', () => {
+      var text = 'button text';
+      var $button = ButtonComponent.render({text: text});
+      expect($button.text()).toEqual(text);
+    });
+
+    it('with additional class', () => {
+      var className = 'aclass';
+      var $button = ButtonComponent.render({additionalClasses: className});
+      expect($button.hasClass(className)).toBe(true);
+    });
+
+    it('with additional classes', () => {
+      var classNames = ['classa','classb'];
+      var $button = ButtonComponent.render({additionalClasses: classNames});
+      for(var i = 0; i < classNames.length; i++){
+        expect($button.hasClass(classNames[i])).toBe(true);
+      }
+    });
+
+    it('with type', () => {
+      var type = 'secondary';
+      var $button = ButtonComponent.render({type: type});
+      expect($button.hasClass('aui-button-' + type)).toBe(true);
+    });
+
+    it('with disabled', () => {
+      var $button = ButtonComponent.render({disabled: true});
+      expect($button.attr('aria-disabled')).toEqual('true');
+    });
+
+  });
+
+  describe('button click', () => {
+    it('does not dispatch an event when disabled', (done) => {
+      var $button = ButtonComponent.render({disabled: true});
+      document.body.appendChild($button[0]);
+      var spy = jasmine.createSpy('spy');
+      EventDispatcher.registerOnce('button-clicked', spy);
+
+      // jquery bug, need to wait 1 tick before triggering.
+      setTimeout(function(){
+        $button.trigger('click');
+      }, 0);
+
+      // wait longer than the 1 tick to make sure it's not triggered.
+      setTimeout(function(){
+        expect(spy).not.toHaveBeenCalled();
+        done();
+      }, 10);
+    });
+
+    it('disaptches an event', (done) => {
+      var $button = ButtonComponent.render({disabled: false});
+      document.body.appendChild($button[0]);
+      EventDispatcher.registerOnce('button-clicked', (data) => {
+        expect(data.$el.attr('id')).toEqual($button.attr('id'));
+        done();
+      });
+      // jquery bug, need to wait 1 tick before triggering.
+      setTimeout(function(){
+        $button.trigger('click');
+      }, 0);
+    });
+
+  });
+
+  describe('button toggle', () => {
+    it('state to disabled', () => {
+      var $button = ButtonComponent.render();
+      expect(ButtonComponent.isEnabled($button)).toBe(true);
+      ButtonComponent.setDisabled($button, true);
+      expect(ButtonComponent.isEnabled($button)).toBe(false);
+    });
+
+    it('state to enabled', () => {
+      var $button = ButtonComponent.render({disabled: true});
+      expect(ButtonComponent.isEnabled($button)).toBe(false);
+      ButtonComponent.setDisabled($button, false);
+      expect(ButtonComponent.isEnabled($button)).toBe(true);
+    });
+
+    it('visibility to hidden', () => {
+      var $button = ButtonComponent.render();
+      document.body.appendChild($button[0]);
+      expect($button.is(':visible')).toBe(true);
+      ButtonComponent.setHidden($button, true);
+      expect($button.is(':visible')).toBe(false);
+    });
+
+    it('visibility to visible', () => {
+      var $button = ButtonComponent.render();
+      document.body.appendChild($button[0]);
+      $button.hide();
+      expect($button.is(':visible')).toBe(false);
+      ButtonComponent.setHidden($button, false);
+      expect($button.is(':visible')).toBe(true);
+    });
+  });
+
+  describe('immutable button toggle', () => {
+    it('state to disabled', () => {
+      var $button = ButtonComponent.render({immutable: true});
+      expect(ButtonComponent.isEnabled($button)).toBe(true);
+      ButtonComponent.setDisabled($button, true);
+      expect(ButtonComponent.isEnabled($button)).toBe(true);
+    });
+
+    it('visibility to hidden', () => {
+      var $button = ButtonComponent.render({immutable: true});
+      document.body.appendChild($button[0]);
+      expect($button.is(':visible')).toBe(true);
+      ButtonComponent.setHidden($button, true);
+      expect($button.is(':visible')).toBe(true);
+    });
+  });
+
+});

package/spec/tests/dialog_extension_spec.js

@@ -0,0 +1,59 @@
+import DialogExtensionComponent from 'src/host/components/dialog_extension';
+import baseDialogComponentTests from 'fixtures/base_dialog_component_tests';
+
+describe('dialog extension component', () => {
+  afterEach(() => {
+    $('.aui-dialog2').remove();
+    $('.aui-blanket').remove();
+  });
+  describe('render', () => {
+    var extension = {
+      addon_key: 'some-key',
+      key: 'module-key',
+      url: 'https://www.example.com'
+    };
+
+    it('renders a chromeless dialog', () => {
+      var options = baseDialogComponentTests.getChromelessOptions();
+      expect($('.aui-dialog2').length).toEqual(0);
+      DialogExtensionComponent.render(extension, options);
+      expect($('.aui-dialog2').length).toEqual(1);
+      baseDialogComponentTests.testChromeless(options);
+    });
+
+    it('renders a dialog with chrome', () => {
+      var options = baseDialogComponentTests.getChromeOptions();
+      expect($('.aui-dialog2').length).toEqual(0);
+      DialogExtensionComponent.render(extension, options);
+      expect($('.aui-dialog2').length).toEqual(1);
+      baseDialogComponentTests.testChrome(options);
+    });
+
+    it('renders a dialog with chrome in fullscreen', () => {
+      var options = baseDialogComponentTests.getFullscreenOptions();
+      expect($('.aui-dialog2').length).toEqual(0);
+      DialogExtensionComponent.render(extension, options);
+      expect($('.aui-dialog2').length).toEqual(1);
+      baseDialogComponentTests.testFullScreen(options);
+    });
+
+
+    it('contains an iframe', () => {
+      DialogExtensionComponent.render(extension);
+      expect($('.aui-dialog2 iframe').length).toEqual(1);
+    });
+
+    it('correct dimensions', () => {
+      var dimensions = {
+        width: 456,
+        height: 321
+      };
+      DialogExtensionComponent.render(extension, dimensions);
+      var $iframe = $('.aui-dialog2 iframe');
+      expect($iframe.length).toEqual(1);
+      expect($iframe.width()).toEqual(dimensions.width);
+      expect($iframe.height()).toEqual(dimensions.height);
+    });
+
+  });
+});