The Tor Browser: addon-sdk/source/test/test-ui-sidebar.js@129ffea94266

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

     1 /* This Source Code Form is subject to the terms of the Mozilla Public

     2  * License, v. 2.0. If a copy of the MPL was not distributed with this

     3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     4 'use strict';

     6 module.metadata = {

     7   'engines': {

     8     'Firefox': '*'

     9   }

    10 };

    12 const { Cu } = require('chrome');

    13 const { Loader } = require('sdk/test/loader');

    14 const { show, hide } = require('sdk/ui/sidebar/actions');

    15 const { isShowing } = require('sdk/ui/sidebar/utils');

    16 const { getMostRecentBrowserWindow } = require('sdk/window/utils');

    17 const { open, close, focus, promise: windowPromise } = require('sdk/window/helpers');

    18 const { setTimeout, setImmediate } = require('sdk/timers');

    19 const { isPrivate } = require('sdk/private-browsing');

    20 const data = require('./fixtures');

    21 const { URL } = require('sdk/url');

    22 const { once, off, emit } = require('sdk/event/core');

    23 const { defer, all } = require('sdk/core/promise');

    25 const { BUILTIN_SIDEBAR_MENUITEMS, isSidebarShowing,

    26         getSidebarMenuitems, getExtraSidebarMenuitems, makeID, simulateCommand,

    27         simulateClick, isChecked } = require('./sidebar/utils');

    29 exports.testSidebarBasicLifeCycle = function(assert, done) {

    30   const { Sidebar } = require('sdk/ui/sidebar');

    31   let testName = 'testSidebarBasicLifeCycle';

    32   let window = getMostRecentBrowserWindow();

    33   assert.ok(!window.document.getElementById(makeID(testName)), 'sidebar id DNE');

    34   let sidebarXUL = window.document.getElementById('sidebar');

    35   assert.ok(sidebarXUL, 'sidebar xul element does exist');

    36   assert.ok(!getExtraSidebarMenuitems().length, 'there are no extra sidebar menuitems');

    38   assert.equal(isSidebarShowing(window), false, 'sidebar is not showing 1');

    39   let sidebarDetails = {

    40     id: testName,

    41     title: 'test',

    42     url: 'data:text/html;charset=utf-8,'+testName

    43   };

    44   let sidebar = Sidebar(sidebarDetails);

    46   // test the sidebar attributes

    47   for (let key of Object.keys(sidebarDetails)) {

    48     assert.equal(sidebarDetails[key], sidebar[key], 'the attributes match the input');

    49   }

    51   assert.pass('The Sidebar constructor worked');

    53   let extraMenuitems = getExtraSidebarMenuitems();

    54   assert.equal(extraMenuitems.length, 1, 'there is one extra sidebar menuitems');

    56   let ele = window.document.getElementById(makeID(testName));

    57   assert.equal(ele, extraMenuitems[0], 'the only extra menuitem is the one for our sidebar.')

    58   assert.ok(ele, 'sidebar element was added');

    59   assert.ok(!isChecked(ele), 'the sidebar is not displayed');

    60   assert.equal(ele.getAttribute('label'), sidebar.title, 'the sidebar title is the menuitem label')

    62   assert.equal(isSidebarShowing(window), false, 'sidebar is not showing 2');

    63   sidebar.on('show', function() {

    64     assert.pass('the show event was fired');

    65     assert.equal(isSidebarShowing(window), true, 'sidebar is not showing 3');

    66     assert.equal(isShowing(sidebar), true, 'the sidebar is showing');

    67     assert.ok(isChecked(ele), 'the sidebar is displayed');

    69     sidebar.once('hide', function() {

    70       assert.pass('the hide event was fired');

    71       assert.ok(!isChecked(ele), 'the sidebar menuitem is not checked');

    72       assert.equal(isShowing(sidebar), false, 'the sidebar is not showing');

    73       assert.equal(isSidebarShowing(window), false, 'the sidebar elemnt is hidden');

    75       sidebar.once('detach', function() {

    76         // calling destroy twice should not matter

    77         sidebar.destroy();

    78         sidebar.destroy();

    80         let sidebarMI = getSidebarMenuitems();

    81         for (let mi of sidebarMI) {

    82           assert.ok(BUILTIN_SIDEBAR_MENUITEMS.indexOf(mi.getAttribute('id')) >= 0, 'the menuitem is for a built-in sidebar')

    83           assert.ok(!isChecked(mi), 'no sidebar menuitem is checked');

    84         }

    86         assert.ok(!window.document.getElementById(makeID(testName)), 'sidebar id DNE');

    87         assert.pass('calling destroy worked without error');

    89         done();

    90       });

    91     });

    93     sidebar.hide();

    94     assert.pass('hiding sidebar..');

    95   });

    97   sidebar.show();

    98   assert.pass('showing sidebar..');

    99 }

   101 exports.testSideBarIsInNewWindows = function(assert, done) {

   102   const { Sidebar } = require('sdk/ui/sidebar');

   103   let testName = 'testSideBarIsInNewWindows';

   104   let sidebar = Sidebar({

   105     id: testName,

   106     title: testName,

   107     url: 'data:text/html;charset=utf-8,'+testName

   108   });

   110   let startWindow = getMostRecentBrowserWindow();

   111   let ele = startWindow.document.getElementById(makeID(testName));

   112   assert.ok(ele, 'sidebar element was added');

   114   open().then(function(window) {

   115       let ele = window.document.getElementById(makeID(testName));

   116       assert.ok(ele, 'sidebar element was added');

   118       // calling destroy twice should not matter

   119       sidebar.destroy();

   120       sidebar.destroy();

   122       assert.ok(!window.document.getElementById(makeID(testName)), 'sidebar id DNE');

   123       assert.ok(!startWindow.document.getElementById(makeID(testName)), 'sidebar id DNE');

   125       close(window).then(done, assert.fail);

   126   })

   127 }

   129 exports.testSideBarIsShowingInNewWindows = function(assert, done) {

   130   const { Sidebar } = require('sdk/ui/sidebar');

   131   let testName = 'testSideBarIsShowingInNewWindows';

   132   let sidebar = Sidebar({

   133     id: testName,

   134     title: testName,

   135     url: URL('data:text/html;charset=utf-8,'+testName)

   136   });

   138   let startWindow = getMostRecentBrowserWindow();

   139   let ele = startWindow.document.getElementById(makeID(testName));

   140   assert.ok(ele, 'sidebar element was added');

   142   let oldEle = ele;

   143   sidebar.once('attach', function() {

   144     assert.pass('attach event fired');

   146     sidebar.once('show', function() {

   147       assert.pass('show event fired');

   149       sidebar.once('show', function() {

   150         let window = getMostRecentBrowserWindow();

   151         assert.notEqual(startWindow, window, 'window is new');

   153         let sb = window.document.getElementById('sidebar');

   154         if (sb && sb.docShell && sb.contentDocument && sb.contentDocument.getElementById('web-panels-browser')) {

   155           end();

   156         }

   157         else {

   158           sb.addEventListener('DOMWindowCreated', end, false);

   159         }

   161         function end() {

   162           sb.removeEventListener('DOMWindowCreated', end, false);

   163           let webPanelBrowser = sb.contentDocument.getElementById('web-panels-browser');

   165           let ele = window.document.getElementById(makeID(testName));

   167           assert.ok(ele, 'sidebar element was added 2');

   168           assert.ok(isChecked(ele), 'the sidebar is checked');

   169           assert.notEqual(ele, oldEle, 'there are two different sidebars');

   171           assert.equal(isShowing(sidebar), true, 'the sidebar is showing in new window');

   174             sidebar.destroy();

   176             assert.equal(isShowing(sidebar), false, 'the sidebar is not showing');

   177             assert.ok(!isSidebarShowing(window), 'sidebar in most recent window is not showing');

   178             assert.ok(!isSidebarShowing(startWindow), 'sidebar in most start window is not showing');

   179             assert.ok(!window.document.getElementById(makeID(testName)), 'sidebar id DNE');

   180             assert.ok(!startWindow.document.getElementById(makeID(testName)), 'sidebar id DNE');

   182             setTimeout(function() {

   183               close(window).then(done, assert.fail);

   184             });

   185         }

   186       });

   188       startWindow.OpenBrowserWindow();

   189     });

   190   });

   192   show(sidebar);

   193   assert.pass('showing the sidebar');

   194 }

   196 // TODO: determine if this is acceptable..

   197 /*

   198 exports.testAddonGlobalSimple = function(assert, done) {

   199   const { Sidebar } = require('sdk/ui/sidebar');

   200   let testName = 'testAddonGlobalSimple';

   201   let sidebar = Sidebar({

   202     id: testName,

   203     title: testName,

   204     url: data.url('test-sidebar-addon-global.html')

   205   });

   207   sidebar.on('show', function({worker}) {

   208     assert.pass('sidebar was attached');

   209     assert.ok(!!worker, 'attach event has worker');

   211     worker.port.on('X', function(msg) {

   212       assert.equal(msg, '23', 'the final message is correct');

   214       sidebar.destroy();

   216       done();

   217     });

   218     worker.port.emit('X', '2');

   219   });

   220   show(sidebar);

   221 }

   222 */

   224 exports.testAddonGlobalComplex = function(assert, done) {

   225   const { Sidebar } = require('sdk/ui/sidebar');

   226   let testName = 'testAddonGlobalComplex';

   227   let sidebar = Sidebar({

   228     id: testName,

   229     title: testName,

   230     url: data.url('test-sidebar-addon-global.html')

   231   });

   233   sidebar.on('attach', function(worker) {

   234     assert.pass('sidebar was attached');

   235     assert.ok(!!worker, 'attach event has worker');

   237     worker.port.once('Y', function(msg) {

   238       assert.equal(msg, '1', 'got event from worker');

   240       worker.port.on('X', function(msg) {

   241         assert.equal(msg, '123', 'the final message is correct');

   243         sidebar.destroy();

   245         done();

   246       });

   247       worker.port.emit('X', msg + '2');

   248     })

   249   });

   251   show(sidebar);

   252 }

   254 exports.testAddonReady = function(assert, done) {

   255   const { Sidebar } = require('sdk/ui/sidebar');

   256   let testName = 'testAddonReady';

   257   let sidebar = Sidebar({

   258     id: testName,

   259     title: testName,

   260     url: data.url('test-sidebar-addon-global.html'),

   261     onReady: function(worker) {

   262       assert.pass('sidebar was attached');

   263       assert.ok(!!worker, 'attach event has worker');

   265       worker.port.on('X', function(msg) {

   266         assert.equal(msg, '123', 'the final message is correct');

   268         sidebar.destroy();

   270         done();

   271       });

   273       worker.port.emit('X', '12');

   274     }

   275   });

   277   show(sidebar);

   278 }

   280 exports.testShowingOneSidebarAfterAnother = function(assert, done) {

   281   const { Sidebar } = require('sdk/ui/sidebar');

   282   let testName = 'testShowingOneSidebarAfterAnother';

   284   let sidebar1 = Sidebar({

   285     id: testName + '1',

   286     title: testName + '1',

   287     url:  'data:text/html;charset=utf-8,'+ testName + 1

   288   });

   289   let sidebar2 = Sidebar({

   290     id: testName + '2',

   291     title: testName + '2',

   292     url:  'data:text/html;charset=utf-8,'+ testName + 2

   293   });

   295   let window = getMostRecentBrowserWindow();

   296   let IDs = [ sidebar1.id, sidebar2.id ];

   298   let extraMenuitems = getExtraSidebarMenuitems(window);

   299   assert.equal(extraMenuitems.length, 2, 'there are two extra sidebar menuitems');

   301   function testShowing(sb1, sb2, sbEle) {

   302     assert.equal(isShowing(sidebar1), sb1);

   303     assert.equal(isShowing(sidebar2), sb2);

   304     assert.equal(isSidebarShowing(window), sbEle);

   305   }

   306   testShowing(false, false, false);

   308   sidebar1.once('show', function() {

   309     testShowing(true, false, true);

   310     for (let mi of getExtraSidebarMenuitems(window)) {

   311       let menuitemID = mi.getAttribute('id').replace(/^jetpack-sidebar-/, '');

   312       assert.ok(IDs.indexOf(menuitemID) >= 0, 'the extra menuitem is for one of our test sidebars');

   313       assert.equal(isChecked(mi), menuitemID == sidebar1.id, 'the test sidebar menuitem has the correct checked value');

   314     }

   316     sidebar2.once('show', function() {

   317       testShowing(false, true, true);

   318       for (let mi of getExtraSidebarMenuitems(window)) {

   319         let menuitemID = mi.getAttribute('id').replace(/^jetpack-sidebar-/, '');

   320         assert.ok(IDs.indexOf(menuitemID) >= 0, 'the extra menuitem is for one of our test sidebars');

   321         assert.equal(isChecked(mi), menuitemID == sidebar2.id, 'the test sidebar menuitem has the correct checked value');

   322       }

   324       sidebar1.destroy();

   325       sidebar2.destroy();

   327       testShowing(false, false, false);

   329       done();

   330     });

   332     show(sidebar2);

   333     assert.pass('showing sidebar 2');

   334   })

   335   show(sidebar1);

   336   assert.pass('showing sidebar 1');

   337 }

   339 exports.testSidebarUnload = function(assert, done) {

   340   const { Sidebar } = require('sdk/ui/sidebar');

   341   let testName = 'testSidebarUnload';

   342   let loader = Loader(module);

   344   let window = getMostRecentBrowserWindow();

   346   assert.equal(isPrivate(window), false, 'the current window is not private');

   348   let sidebar = loader.require('sdk/ui/sidebar').Sidebar({

   349     id: testName,

   350     title: testName,

   351     url:  'data:text/html;charset=utf-8,'+ testName,

   352     onShow: function() {

   353       assert.pass('onShow works for Sidebar');

   354       loader.unload();

   356       let sidebarMI = getSidebarMenuitems();

   357       for (let mi of sidebarMI) {

   358         assert.ok(BUILTIN_SIDEBAR_MENUITEMS.indexOf(mi.getAttribute('id')) >= 0, 'the menuitem is for a built-in sidebar')

   359         assert.ok(!isChecked(mi), 'no sidebar menuitem is checked');

   360       }

   361       assert.ok(!window.document.getElementById(makeID(testName)), 'sidebar id DNE');

   362       assert.equal(isSidebarShowing(window), false, 'the sidebar is not showing');

   364       done();

   365     }

   366   })

   368   sidebar.show();

   369   assert.pass('showing the sidebar');

   370 }

   372 exports.testRemoteContent = function(assert) {

   373   const { Sidebar } = require('sdk/ui/sidebar');

   374   let testName = 'testRemoteContent';

   375   try {

   376     let sidebar = Sidebar({

   377       id: testName,

   378       title: testName,

   379       url: 'http://dne.xyz.mozilla.org'

   380     });

   381     assert.fail('a bad sidebar was created..');

   382     sidebar.destroy();

   383   }

   384   catch(e) {

   385     assert.ok(/The option "url" must be a valid local URI\./.test(e), 'remote content is not acceptable');

   386   }

   387 }

   389 exports.testInvalidURL = function(assert) {

   390   const { Sidebar } = require('sdk/ui/sidebar');

   391   let testName = 'testInvalidURL';

   392   try {

   393     let sidebar = Sidebar({

   394       id: testName,

   395       title: testName,

   396       url: 'http:mozilla.org'

   397     });

   398     assert.fail('a bad sidebar was created..');

   399     sidebar.destroy();

   400   }

   401   catch(e) {

   402     assert.ok(/The option "url" must be a valid local URI\./.test(e), 'invalid URIs are not acceptable');

   403   }

   404 }

   406 exports.testInvalidURLType = function(assert) {

   407   const { Sidebar } = require('sdk/ui/sidebar');

   408   let testName = 'testInvalidURLType';

   409   try {

   410     let sidebar = Sidebar({

   411       id: testName,

   412       title: testName

   413     });

   414     assert.fail('a bad sidebar was created..');

   415     sidebar.destroy();

   416   }

   417   catch(e) {

   418     assert.ok(/The option "url" must be a valid local URI\./.test(e), 'invalid URIs are not acceptable');

   419   }

   420 }

   422 exports.testInvalidTitle = function(assert) {

   423   const { Sidebar } = require('sdk/ui/sidebar');

   424   let testName = 'testInvalidTitle';

   425   try {

   426     let sidebar = Sidebar({

   427       id: testName,

   428       title: '',

   429       url: 'data:text/html;charset=utf-8,'+testName

   430     });

   431     assert.fail('a bad sidebar was created..');

   432     sidebar.destroy();

   433   }

   434   catch(e) {

   435     assert.equal('The option "title" must be one of the following types: string', e.message, 'invalid titles are not acceptable');

   436   }

   437 }

   439 exports.testInvalidID = function(assert) {

   440   const { Sidebar } = require('sdk/ui/sidebar');

   441   let testName = 'testInvalidID';

   442   try {

   443     let sidebar = Sidebar({

   444       id: '!',

   445       title: testName,

   446       url: 'data:text/html;charset=utf-8,'+testName

   447     });

   448     assert.fail('a bad sidebar was created..');

   449     sidebar.destroy();

   450   }

   451   catch(e) {

   452     assert.ok(/The option "id" must be a valid alphanumeric id/.test(e), 'invalid ids are not acceptable');

   453   }

   454 }

   456 exports.testInvalidBlankID = function(assert) {

   457   const { Sidebar } = require('sdk/ui/sidebar');

   458   let testName = 'testInvalidBlankID';

   459   try {

   460     let sidebar = Sidebar({

   461       id: '',

   462       title: testName,

   463       url: 'data:text/html;charset=utf-8,'+testName

   464     });

   465     assert.fail('a bad sidebar was created..');

   466     sidebar.destroy();

   467   }

   468   catch(e) {

   469     assert.ok(/The option "id" must be a valid alphanumeric id/.test(e), 'invalid ids are not acceptable');

   470   }

   471 }

   473 exports.testInvalidNullID = function(assert) {

   474   const { Sidebar } = require('sdk/ui/sidebar');

   475   let testName = 'testInvalidNullID';

   476   try {

   477     let sidebar = Sidebar({

   478       id: null,

   479       title: testName,

   480       url: 'data:text/html;charset=utf-8,'+testName

   481     });

   482     assert.fail('a bad sidebar was created..');

   483     sidebar.destroy();

   484   }

   485   catch(e) {

   486     assert.ok(/The option "id" must be a valid alphanumeric id/.test(e), 'invalid ids are not acceptable');

   487   }

   488 }

   490 exports.testUndefinedID = function(assert) {

   491   const { Sidebar } = require('sdk/ui/sidebar');

   492   let testName = 'testInvalidUndefinedID';

   494   try {

   495     let sidebar = Sidebar({

   496       title: testName,

   497       url: 'data:text/html;charset=utf-8,' + testName

   498     });

   500     assert.ok(sidebar.id, 'an undefined id was accepted, id was creawted: ' + sidebar.id);

   501     assert.ok(getMostRecentBrowserWindow().document.getElementById(makeID(sidebar.id)), 'the sidebar element was found');

   503     sidebar.destroy();

   504   }

   505   catch(e) {

   506     assert.fail('undefined ids are acceptable');

   507     assert.fail(e.message);

   508   }

   509 }

   511 // TEST: edge case where web panel is destroyed while loading

   512 exports.testDestroyEdgeCaseBug = function(assert, done) {

   513   const { Sidebar } = require('sdk/ui/sidebar');

   514   let testName = 'testDestroyEdgeCaseBug';

   515   let window = getMostRecentBrowserWindow();

   516   let sidebar = Sidebar({

   517     id: testName,

   518     title: testName,

   519     url: 'data:text/html;charset=utf-8,'+testName

   520   });

   522   // NOTE: purposely not listening to show event b/c the event happens

   523   //       between now and then.

   524   sidebar.show();

   526   assert.equal(isPrivate(window), false, 'the new window is not private');

   527   assert.equal(isSidebarShowing(window), true, 'the sidebar is showing');

   529   //assert.equal(isShowing(sidebar), true, 'the sidebar is showing');

   531   open().then(focus).then(function(window2) {

   532     assert.equal(isPrivate(window2), false, 'the new window is not private');

   533     assert.equal(isSidebarShowing(window2), false, 'the sidebar is not showing');

   534     assert.equal(isShowing(sidebar), false, 'the sidebar is not showing');

   536     sidebar.destroy();

   537     assert.pass('destroying the sidebar');

   539     close(window2).then(function() {

   540       let loader = Loader(module);

   542       assert.equal(isPrivate(window), false, 'the current window is not private');

   544       let sidebar = loader.require('sdk/ui/sidebar').Sidebar({

   545         id: testName,

   546         title: testName,

   547         url:  'data:text/html;charset=utf-8,'+ testName,

   548         onShow: function() {

   549           assert.pass('onShow works for Sidebar');

   550           loader.unload();

   552           let sidebarMI = getSidebarMenuitems();

   553           for (let mi of sidebarMI) {

   554             assert.ok(BUILTIN_SIDEBAR_MENUITEMS.indexOf(mi.getAttribute('id')) >= 0, 'the menuitem is for a built-in sidebar')

   555             assert.ok(!isChecked(mi), 'no sidebar menuitem is checked');

   556           }

   557           assert.ok(!window.document.getElementById(makeID(testName)), 'sidebar id DNE');

   558           assert.equal(isSidebarShowing(window), false, 'the sidebar is not showing');

   560           done();

   561         }

   562       })

   564       sidebar.show();

   565       assert.pass('showing the sidebar');

   567     });

   568   });

   569 }

   571 exports.testClickingACheckedMenuitem = function(assert, done) {

   572   const { Sidebar } = require('sdk/ui/sidebar');

   573   let testName = 'testClickingACheckedMenuitem';

   574   let window = getMostRecentBrowserWindow();

   575   let sidebar = Sidebar({

   576     id: testName,

   577     title: testName,

   578     url: 'data:text/html;charset=utf-8,'+testName,

   579   });

   581   sidebar.show().then(function() {

   582     assert.pass('the show callback works');

   584     sidebar.once('hide', function() {

   585       assert.pass('clicking the menuitem after the sidebar has shown hides it.');

   586       sidebar.destroy();

   587       done();

   588     });

   590     let menuitem = window.document.getElementById(makeID(sidebar.id));

   591     simulateCommand(menuitem);

   592   });

   593 };

   595 exports.testTitleSetter = function(assert, done) {

   596   const { Sidebar } = require('sdk/ui/sidebar');

   597   let testName = 'testTitleSetter';

   598   let { document } = getMostRecentBrowserWindow();

   600   let sidebar1 = Sidebar({

   601     id: testName,

   602     title: testName,

   603     url: 'data:text/html;charset=utf-8,'+testName,

   604   });

   606   assert.equal(sidebar1.title, testName, 'title getter works');

   608   sidebar1.show().then(function() {

   609     assert.equal(document.getElementById(makeID(sidebar1.id)).getAttribute('label'),

   610                  testName,

   611                  'the menuitem label is correct');

   613     assert.equal(document.getElementById('sidebar-title').value, testName, 'the menuitem label is correct');

   615     sidebar1.title = 'foo';

   617     assert.equal(sidebar1.title, 'foo', 'title getter works');

   619     assert.equal(document.getElementById(makeID(sidebar1.id)).getAttribute('label'),

   620                  'foo',

   621                  'the menuitem label was updated');

   623     assert.equal(document.getElementById('sidebar-title').value, 'foo', 'the sidebar title was updated');

   625     sidebar1.destroy();

   626     done();

   627   }, assert.fail);

   628 }

   630 exports.testURLSetter = function(assert, done) {

   631   const { Sidebar } = require('sdk/ui/sidebar');

   632   let testName = 'testURLSetter';

   633   let window = getMostRecentBrowserWindow();

   634   let { document } = window;

   635   let url = 'data:text/html;charset=utf-8,'+testName;

   637   let sidebar1 = Sidebar({

   638     id: testName,

   639     title: testName,

   640     url: url

   641   });

   643   assert.equal(sidebar1.url, url, 'url getter works');

   644   assert.equal(isShowing(sidebar1), false, 'the sidebar is not showing');

   645   assert.ok(!isChecked(document.getElementById(makeID(sidebar1.id))),

   646                'the menuitem is not checked');

   647   assert.equal(isSidebarShowing(window), false, 'the new window sidebar is not showing');

   649   windowPromise(window.OpenBrowserWindow(), 'load').then(function(window) {

   650     let { document } = window;

   651     assert.pass('new window was opened');

   653     sidebar1.show().then(function() {

   654       assert.equal(isShowing(sidebar1), true, 'the sidebar is showing');

   655       assert.ok(isChecked(document.getElementById(makeID(sidebar1.id))),

   656                    'the menuitem is checked');

   657       assert.ok(isSidebarShowing(window), 'the new window sidebar is showing');

   659       sidebar1.once('show', function() {

   660         assert.pass('setting the sidebar.url causes a show event');

   662         assert.equal(isShowing(sidebar1), true, 'the sidebar is showing');

   663         assert.ok(isSidebarShowing(window), 'the new window sidebar is still showing');

   665         assert.ok(isChecked(document.getElementById(makeID(sidebar1.id))),

   666                      'the menuitem is still checked');

   668         sidebar1.destroy();

   670         close(window).then(done);

   671       });

   673       sidebar1.url = (url + '1');

   675       assert.equal(sidebar1.url, (url + '1'), 'url getter works');

   676       assert.equal(isShowing(sidebar1), true, 'the sidebar is showing');

   677       assert.ok(isSidebarShowing(window), 'the new window sidebar is showing');

   678     }, assert.fail);

   679   }, assert.fail);

   680 }

   682 exports.testDuplicateID = function(assert) {

   683   const { Sidebar } = require('sdk/ui/sidebar');

   684   let testName = 'testDuplicateID';

   685   let window = getMostRecentBrowserWindow();

   686   let { document } = window;

   687   let url = 'data:text/html;charset=utf-8,'+testName;

   689   let sidebar1 = Sidebar({

   690     id: testName,

   691     title: testName,

   692     url: url

   693   });

   695   assert.throws(function() {

   696     Sidebar({

   697       id: testName,

   698       title: testName + 1,

   699       url: url + 2

   700     }).destroy();

   701   }, /The ID .+ seems already used\./i, 'duplicate IDs will throw errors');

   703   sidebar1.destroy();

   704 }

   706 exports.testURLSetterToSameValueReloadsSidebar = function(assert, done) {

   707   const { Sidebar } = require('sdk/ui/sidebar');

   708   let testName = 'testURLSetterToSameValueReloadsSidebar';

   709   let window = getMostRecentBrowserWindow();

   710   let { document } = window;

   711   let url = 'data:text/html;charset=utf-8,'+testName;

   713   let sidebar1 = Sidebar({

   714     id: testName,

   715     title: testName,

   716     url: url

   717   });

   719   assert.equal(sidebar1.url, url, 'url getter works');

   720   assert.equal(isShowing(sidebar1), false, 'the sidebar is not showing');

   721   assert.ok(!isChecked(document.getElementById(makeID(sidebar1.id))),

   722                'the menuitem is not checked');

   723   assert.equal(isSidebarShowing(window), false, 'the new window sidebar is not showing');

   725   windowPromise(window.OpenBrowserWindow(), 'load').then(function(window) {

   726     let { document } = window;

   727     assert.pass('new window was opened');

   729     sidebar1.show().then(function() {

   730       assert.equal(isShowing(sidebar1), true, 'the sidebar is showing');

   731       assert.ok(isChecked(document.getElementById(makeID(sidebar1.id))),

   732                    'the menuitem is checked');

   733       assert.ok(isSidebarShowing(window), 'the new window sidebar is showing');

   735       sidebar1.once('show', function() {

   736         assert.pass('setting the sidebar.url causes a show event');

   738         assert.equal(isShowing(sidebar1), true, 'the sidebar is showing');

   739         assert.ok(isSidebarShowing(window), 'the new window sidebar is still showing');

   741         assert.ok(isChecked(document.getElementById(makeID(sidebar1.id))),

   742                      'the menuitem is still checked');

   744         sidebar1.destroy();

   746         close(window).then(done);

   747       });

   749       sidebar1.url = url;

   751       assert.equal(sidebar1.url, url, 'url getter works');

   752       assert.equal(isShowing(sidebar1), true, 'the sidebar is showing');

   753       assert.ok(isSidebarShowing(window), 'the new window sidebar is showing');

   754     }, assert.fail);

   755   }, assert.fail);

   756 }

   758 exports.testShowingInOneWindowDoesNotAffectOtherWindows = function(assert, done) {

   759   const { Sidebar } = require('sdk/ui/sidebar');

   760   let testName = 'testShowingInOneWindowDoesNotAffectOtherWindows';

   761   let window1 = getMostRecentBrowserWindow();

   762   let url = 'data:text/html;charset=utf-8,'+testName;

   764   let sidebar1 = Sidebar({

   765     id: testName,

   766     title: testName,

   767     url: url

   768   });

   770   assert.equal(sidebar1.url, url, 'url getter works');

   771   assert.equal(isShowing(sidebar1), false, 'the sidebar is not showing');

   772   let checkCount = 1;

   773   function checkSidebarShowing(window, expected) {

   774     assert.pass('check count ' + checkCount++);

   776     let mi = window.document.getElementById(makeID(sidebar1.id));

   777     if (mi) {

   778       assert.equal(isChecked(mi), expected,

   779                    'the menuitem is not checked');

   780     }

   781     assert.equal(isSidebarShowing(window), expected || false, 'the new window sidebar is not showing');

   782   }

   783   checkSidebarShowing(window1, false);

   785   windowPromise(window1.OpenBrowserWindow(), 'load').then(function(window) {

   786     let { document } = window;

   787     assert.pass('new window was opened!');

   789     // waiting for show

   790     sidebar1.once('show', function() {

   791       // check state of the new window

   792       assert.equal(isShowing(sidebar1), true, 'the sidebar is showing');

   793       checkSidebarShowing(window, true);

   795       // check state of old window

   796       checkSidebarShowing(window1, false);

   798       // waiting for show using url setter

   799       sidebar1.once('show', function() {

   800         assert.pass('setting the sidebar.url causes a new show event');

   802         // check state of the new window

   803         assert.equal(isShowing(sidebar1), true, 'the sidebar is showing');

   804         checkSidebarShowing(window, true);

   806         // check state of old window

   807         checkSidebarShowing(window1, false);

   809         // calling destroy() twice should not matter

   810         sidebar1.destroy();

   811         sidebar1.destroy();

   813         // check state of the new window

   814         assert.equal(isShowing(sidebar1), false, 'the sidebar is not showing');

   815         checkSidebarShowing(window, undefined);

   817         // check state of old window

   818         checkSidebarShowing(window1, undefined);

   820         close(window).then(done);

   821       });

   823       assert.pass('setting sidebar1.url');

   824       sidebar1.url += '1';

   825       assert.pass('set sidebar1.url');

   826     });

   828     sidebar1.show();

   829   }, assert.fail);

   830 }

   832 exports.testHidingAHiddenSidebarRejects = function(assert, done) {

   833   const { Sidebar } = require('sdk/ui/sidebar');

   834   let testName = 'testHidingAHiddenSidebarRejects';

   835   let url = 'data:text/html;charset=utf-8,'+testName;

   836   let sidebar = Sidebar({

   837     id: testName,

   838     title: testName,

   839     url: url

   840   });

   842   sidebar.hide().then(assert.fail, assert.pass).then(function() {

   843     sidebar.destroy();

   844     done();

   845   }, assert.fail);

   846 }

   848 exports.testGCdSidebarsOnUnload = function(assert, done) {

   849   const loader = Loader(module);

   850   const { Sidebar } = loader.require('sdk/ui/sidebar');

   851   const window = getMostRecentBrowserWindow();

   853   let testName = 'testGCdSidebarsOnUnload';

   854   let url = 'data:text/html;charset=utf-8,'+testName;

   856   assert.equal(isSidebarShowing(window), false, 'the sidebar is not showing');

   858   // IMPORTANT: make no reference to the sidebar instance, so it is GC'd

   859   let sidebar = Sidebar({

   860     id: testName,

   861     title: testName,

   862     url: url

   863   });

   865   sidebar.show().then(function() {

   866     sidebar = null;

   868     assert.equal(isSidebarShowing(window), true, 'the sidebar is showing');

   870     let menuitemID = makeID(testName);

   872     assert.ok(!!window.document.getElementById(menuitemID), 'the menuitem was found');

   874     Cu.schedulePreciseGC(function() {

   875       loader.unload();

   877       assert.equal(isSidebarShowing(window), false, 'the sidebar is not showing after unload');

   878       assert.ok(!window.document.getElementById(menuitemID), 'the menuitem was removed');

   880       done();

   881     })

   882   }, assert.fail).then(null, assert.fail);

   883 }

   885 exports.testGCdShowingSidebarsOnUnload = function(assert, done) {

   886   const loader = Loader(module);

   887   const { Sidebar } = loader.require('sdk/ui/sidebar');

   888   const window = getMostRecentBrowserWindow();

   890   let testName = 'testGCdShowingSidebarsOnUnload';

   891   let url = 'data:text/html;charset=utf-8,'+testName;

   893   assert.equal(isSidebarShowing(window), false, 'the sidebar is not showing');

   895   let sidebar = Sidebar({

   896     id: testName,

   897     title: testName,

   898     url: url

   899   });

   901   sidebar.on('show', function() {

   902     sidebar = null;

   904     assert.equal(isSidebarShowing(window), true, 'the sidebar is showing');

   906     let menuitemID = makeID(testName);

   908     assert.ok(!!window.document.getElementById(menuitemID), 'the menuitem was found');

   910     Cu.schedulePreciseGC(function() {

   911       assert.equal(isSidebarShowing(window), true, 'the sidebar is still showing after gc');

   912       assert.ok(!!window.document.getElementById(menuitemID), 'the menuitem was found after gc');

   914       loader.unload();

   916       assert.equal(isSidebarShowing(window), false, 'the sidebar is not showing after unload');

   917       assert.ok(!window.document.getElementById(menuitemID), 'the menuitem was removed');

   919       done();

   920     })

   921   });

   923   sidebar.show();

   924 }

   926 exports.testDetachEventOnWindowClose = function(assert, done) {

   927   const loader = Loader(module);

   928   const { Sidebar } = loader.require('sdk/ui/sidebar');

   929   const window = getMostRecentBrowserWindow();

   931   let testName = 'testDetachEventOnWindowClose';

   932   let url = 'data:text/html;charset=utf-8,' + testName;

   935   windowPromise(window.OpenBrowserWindow(), 'load').then(focus).then(function(window) {

   936     let sidebar = Sidebar({

   937       id: testName,

   938       title: testName,

   939       url: url,

   940       onAttach: function() {

   941         assert.pass('the attach event is fired');

   942         window.close();

   943       },

   944       onDetach: function() {

   945         assert.pass('the detach event is fired when the window showing it closes');

   946         loader.unload();

   947         done();

   948       }

   949     });

   951     sidebar.show();

   952   }).then(null, assert.fail);

   953 }

   955 exports.testHideEventOnWindowClose = function(assert, done) {

   956   const loader = Loader(module);

   957   const { Sidebar } = loader.require('sdk/ui/sidebar');

   958   const window = getMostRecentBrowserWindow();

   960   let testName = 'testDetachEventOnWindowClose';

   961   let url = 'data:text/html;charset=utf-8,' + testName;

   964   windowPromise(window.OpenBrowserWindow(), 'load').then(focus).then(function(window) {

   965     let sidebar = Sidebar({

   966       id: testName,

   967       title: testName,

   968       url: url,

   969       onAttach: function() {

   970         assert.pass('the attach event is fired');

   971         window.close();

   972       },

   973       onHide: function() {

   974         assert.pass('the hide event is fired when the window showing it closes');

   975         loader.unload();

   976         done();

   977       }

   978     });

   980     sidebar.show();

   981   }).then(null, assert.fail);

   982 }

   984 exports.testGCdHiddenSidebarsOnUnload = function(assert, done) {

   985   const loader = Loader(module);

   986   const { Sidebar } = loader.require('sdk/ui/sidebar');

   987   const window = getMostRecentBrowserWindow();

   989   let testName = 'testGCdHiddenSidebarsOnUnload';

   990   let url = 'data:text/html;charset=utf-8,'+testName;

   992   assert.equal(isSidebarShowing(window), false, 'the sidebar is not showing');

   994   // IMPORTANT: make no reference to the sidebar instance, so it is GC'd

   995   Sidebar({

   996     id: testName,

   997     title: testName,

   998     url: url

   999   });

  1001   let menuitemID = makeID(testName);

  1003   assert.ok(!!window.document.getElementById(menuitemID), 'the menuitem was found');

  1005   Cu.schedulePreciseGC(function() {

  1006     assert.ok(!!window.document.getElementById(menuitemID), 'the menuitem was found after gc');

  1008     loader.unload();

  1010     assert.ok(!window.document.getElementById(menuitemID), 'the menuitem was removed');

  1012     done();

  1013   });

  1014 }

  1016 exports.testSidebarGettersAndSettersAfterDestroy = function(assert) {

  1017   const { Sidebar } = require('sdk/ui/sidebar');

  1018   let testName = 'testSidebarGettersAndSettersAfterDestroy';

  1019   let url = 'data:text/html;charset=utf-8,'+testName;

  1021   let sidebar = Sidebar({

  1022     id: testName,

  1023     title: testName,

  1024     url: url

  1025   });

  1027   sidebar.destroy();

  1029   assert.equal(sidebar.id, undefined, 'sidebar after destroy has no id');

  1031   assert.throws(() => sidebar.id = 'foo-tang',

  1032     /^setting a property that has only a getter/,

  1033     'id cannot be set at runtime');

  1035   assert.equal(sidebar.id, undefined, 'sidebar after destroy has no id');

  1037   assert.equal(sidebar.title, undefined, 'sidebar after destroy has no title');

  1038   sidebar.title = 'boo-tang';

  1039   assert.equal(sidebar.title, undefined, 'sidebar after destroy has no title');

  1041   assert.equal(sidebar.url, undefined, 'sidebar after destroy has no url');

  1042   sidebar.url = url + 'barz';

  1043   assert.equal(sidebar.url, undefined, 'sidebar after destroy has no url');

  1044 }

  1047 exports.testSidebarLeakCheckDestroyAfterAttach = function(assert, done) {

  1048   const { Sidebar } = require('sdk/ui/sidebar');

  1049   let testName = 'testSidebarLeakCheckDestroyAfterAttach';

  1050   let window = getMostRecentBrowserWindow();

  1051   let sidebar = Sidebar({

  1052     id: testName,

  1053     title: testName,

  1054     url: 'data:text/html;charset=utf-8,'+testName

  1055   });

  1057   sidebar.on('attach', function() {

  1058     assert.pass('the sidebar was shown');

  1060     sidebar.on('show', function() {

  1061       assert.fail('the sidebar show listener should have been removed');

  1062     });

  1063     assert.pass('added a sidebar show listener');

  1065     sidebar.on('hide', function() {

  1066       assert.fail('the sidebar hide listener should have been removed');

  1067     });

  1068     assert.pass('added a sidebar hide listener');

  1070     let panelBrowser = window.document.getElementById('sidebar').contentDocument.getElementById('web-panels-browser');

  1071     panelBrowser.contentWindow.addEventListener('unload', function onUnload() {

  1072       panelBrowser.contentWindow.removeEventListener('unload', onUnload, false);

  1073       // wait a tick..

  1074       setTimeout(function() {

  1075         assert.pass('the sidebar web panel was unloaded properly');

  1076         done();

  1077       })

  1078     }, false);

  1080     sidebar.destroy();

  1081   });

  1083   assert.pass('showing the sidebar');

  1084   sidebar.show();

  1085 }

  1087 exports.testSidebarLeakCheckUnloadAfterAttach = function(assert, done) {

  1088   const loader = Loader(module);

  1089   const { Sidebar } = loader.require('sdk/ui/sidebar');

  1090   let testName = 'testSidebarLeakCheckUnloadAfterAttach';

  1091   let window = getMostRecentBrowserWindow();

  1092   let sidebar = Sidebar({

  1093     id: testName,

  1094     title: testName,

  1095     url: 'data:text/html;charset=utf-8,'+testName

  1096   });

  1098   sidebar.on('attach', function() {

  1099     assert.pass('the sidebar was shown');

  1101     sidebar.on('show', function() {

  1102       assert.fail('the sidebar show listener should have been removed');

  1103     });

  1104     assert.pass('added a sidebar show listener');

  1106     sidebar.on('hide', function() {

  1107       assert.fail('the sidebar hide listener should have been removed');

  1108     });

  1109     assert.pass('added a sidebar hide listener');

  1111     let panelBrowser = window.document.getElementById('sidebar').contentDocument.getElementById('web-panels-browser');

  1112     panelBrowser.contentWindow.addEventListener('unload', function onUnload() {

  1113       panelBrowser.contentWindow.removeEventListener('unload', onUnload, false);

  1114       // wait a tick..

  1115       setTimeout(function() {

  1116         assert.pass('the sidebar web panel was unloaded properly');

  1117         done();

  1118       })

  1119     }, false);

  1121     loader.unload();

  1122   });

  1124   assert.pass('showing the sidebar');

  1125   sidebar.show();

  1126 }

  1128 exports.testTwoSidebarsWithSameTitleAndURL = function(assert) {

  1129   const { Sidebar } = require('sdk/ui/sidebar');

  1130   let testName = 'testTwoSidebarsWithSameTitleAndURL';

  1132   let title = testName;

  1133   let url = 'data:text/html;charset=utf-8,' + testName;

  1135   let sidebar1 = Sidebar({

  1136     id: testName + 1,

  1137     title: title,

  1138     url: url

  1139   });

  1141   assert.throws(function() {

  1142     Sidebar({

  1143       id: testName + 2,

  1144       title: title,

  1145       url: url

  1146     }).destroy();

  1147   }, /title.+url.+invalid/i, 'Creating two sidebars with the same title + url is not allowed');

  1149   let sidebar2 = Sidebar({

  1150     id: testName + 2,

  1151     title: title,

  1152     url: 'data:text/html;charset=utf-8,X'

  1153   });

  1155   assert.throws(function() {

  1156     sidebar2.url = url;

  1157   }, /title.+url.+invalid/i, 'Creating two sidebars with the same title + url is not allowed');

  1159   sidebar2.title = 'foo';

  1160   sidebar2.url = url;

  1162   assert.throws(function() {

  1163     sidebar2.title = title;

  1164   }, /title.+url.+invalid/i, 'Creating two sidebars with the same title + url is not allowed');

  1166   sidebar1.destroy();

  1167   sidebar2.destroy();

  1168 }

  1170 exports.testChangingURLBackToOriginalValue = function(assert) {

  1171   const { Sidebar } = require('sdk/ui/sidebar');

  1172   let testName = 'testChangingURLBackToOriginalValue';

  1174   let title = testName;

  1175   let url = 'data:text/html;charset=utf-8,' + testName;

  1176   let count = 0;

  1178   let sidebar = Sidebar({

  1179     id: testName,

  1180     title: title,

  1181     url: url

  1182   });

  1184   sidebar.url = url + 2;

  1185   assert.equal(sidebar.url, url + 2, 'the sidebar.url is correct');

  1186   sidebar.url = url;

  1187   assert.equal(sidebar.url, url, 'the sidebar.url is correct');

  1189   sidebar.title = 'foo';

  1190   assert.equal(sidebar.title, 'foo', 'the sidebar.title is correct');

  1191   sidebar.title = title;

  1192   assert.equal(sidebar.title, title, 'the sidebar.title is correct');

  1194   sidebar.destroy();

  1196   assert.pass('Changing values back to originals works');

  1197 }

  1199 exports.testShowToOpenXToClose = function(assert, done) {

  1200   const { Sidebar } = require('sdk/ui/sidebar');

  1201   let testName = 'testShowToOpenXToClose';

  1203   let title = testName;

  1204   let url = 'data:text/html;charset=utf-8,' + testName;

  1205   let window = getMostRecentBrowserWindow();

  1207   let sidebar = Sidebar({

  1208     id: testName,

  1209     title: testName,

  1210     url: url,

  1211     onShow: function() {

  1212       assert.ok(isChecked(menuitem), 'menuitem is checked');

  1214       let closeButton = window.document.querySelector('#sidebar-header > toolbarbutton.close-icon');

  1215       simulateCommand(closeButton);

  1216     },

  1217     onHide: function() {

  1218       assert.ok(!isChecked(menuitem), 'menuitem is not checked');

  1220       sidebar.destroy();

  1221       done();

  1222     }

  1223   });

  1225   let menuitem = window.document.getElementById(makeID(sidebar.id));

  1227   assert.ok(!isChecked(menuitem), 'menuitem is not checked');

  1229   sidebar.show();

  1230 }

  1232 exports.testShowToOpenMenuitemToClose = function(assert, done) {

  1233   const { Sidebar } = require('sdk/ui/sidebar');

  1234   let testName = 'testShowToOpenMenuitemToClose';

  1236   let title = testName;

  1237   let url = 'data:text/html;charset=utf-8,' + testName;

  1238   let window = getMostRecentBrowserWindow();

  1240   let sidebar = Sidebar({

  1241     id: testName,

  1242     title: testName,

  1243     url: url,

  1244     onShow: function() {

  1245       assert.ok(isChecked(menuitem), 'menuitem is checked');

  1247       simulateCommand(menuitem);

  1248     },

  1249     onHide: function() {

  1250       assert.ok(!isChecked(menuitem), 'menuitem is not checked');

  1252       sidebar.destroy();

  1253       done();

  1254     }

  1255   });

  1257   let menuitem = window.document.getElementById(makeID(sidebar.id));

  1259   assert.ok(!isChecked(menuitem), 'menuitem is not checked');

  1261   sidebar.show();

  1262 }

  1264 exports.testDestroyWhileNonBrowserWindowIsOpen = function(assert, done) {

  1265   const { Sidebar } = require('sdk/ui/sidebar');

  1266   let testName = 'testDestroyWhileNonBrowserWindowIsOpen';

  1267   let url = 'data:text/html;charset=utf-8,' + testName;

  1269   let sidebar = Sidebar({

  1270     id: testName,

  1271     title: testName,

  1272     url: url

  1273   });

  1275   open('chrome://browser/content/preferences/preferences.xul').then(function(window) {

  1276     try {

  1277       sidebar.show();

  1278       assert.equal(isSidebarShowing(getMostRecentBrowserWindow()), true, 'the sidebar is showing');

  1280       sidebar.destroy();

  1282       assert.pass('sidebar was destroyed while a non browser window was open');

  1283     }

  1284     catch(e) {

  1285       assert.fail(e);

  1286     }

  1288     return window;

  1289   }).then(close).then(function() {

  1290     assert.equal(isSidebarShowing(getMostRecentBrowserWindow()), false, 'the sidebar is not showing');

  1291   }).then(done, assert.fail);

  1292 }

  1294 exports.testEventListeners = function(assert, done) {

  1295   const { Sidebar } = require('sdk/ui/sidebar');

  1296   let testName = 'testWhatThisIsInSidebarEventListeners';

  1297   let eventListenerOrder = [];

  1299   let constructorOnShow = defer();

  1300   let constructorOnHide = defer();

  1301   let constructorOnAttach = defer();

  1302   let constructorOnReady = defer();

  1304   let onShow = defer();

  1305   let onHide = defer();

  1306   let onAttach = defer();

  1307   let onReady = defer();

  1309   let onceShow = defer();

  1310   let onceHide = defer();

  1311   let onceAttach = defer();

  1312   let onceReady = defer();

  1314   function testThis() {

  1315     assert(this, sidebar, '`this` is correct');

  1316   }

  1318   let sidebar = Sidebar({

  1319     id: testName,

  1320     title: testName,

  1321     url: 'data:text/html;charset=utf-8,' + testName,

  1322     onShow: function() {

  1323       assert.equal(this, sidebar, '`this` is correct in onShow');

  1324       eventListenerOrder.push('onShow');

  1325       constructorOnShow.resolve();

  1326     },

  1327     onAttach: function() {

  1328       assert.equal(this, sidebar, '`this` is correct in onAttach');

  1329       eventListenerOrder.push('onAttach');

  1330       constructorOnAttach.resolve();

  1331     },

  1332     onReady: function() {

  1333       assert.equal(this, sidebar, '`this` is correct in onReady');

  1334       eventListenerOrder.push('onReady');

  1335       constructorOnReady.resolve();

  1336     },

  1337     onHide: function() {

  1338       assert.equal(this, sidebar, '`this` is correct in onHide');

  1339       eventListenerOrder.push('onHide');

  1340       constructorOnHide.resolve();

  1341     }

  1342   });

  1344   sidebar.once('show', function() {

  1345     assert.equal(this, sidebar, '`this` is correct in once show');

  1346     eventListenerOrder.push('once show');

  1347     onceShow.resolve();

  1348   });

  1349   sidebar.once('attach', function() {

  1350     assert.equal(this, sidebar, '`this` is correct in once attach');

  1351     eventListenerOrder.push('once attach');

  1352     onceAttach.resolve();

  1353   });

  1354   sidebar.once('ready', function() {

  1355     assert.equal(this, sidebar, '`this` is correct in once ready');

  1356     eventListenerOrder.push('once ready');

  1357     onceReady.resolve();

  1358   });

  1359   sidebar.once('hide', function() {

  1360     assert.equal(this, sidebar, '`this` is correct in once hide');

  1361     eventListenerOrder.push('once hide');

  1362     onceHide.resolve();

  1363   });

  1365   sidebar.on('show', function() {

  1366     assert.equal(this, sidebar, '`this` is correct in on show');

  1367     eventListenerOrder.push('on show');

  1368     onShow.resolve();

  1370     sidebar.hide();

  1371   });

  1372   sidebar.on('attach', function() {

  1373     assert.equal(this, sidebar, '`this` is correct in on attach');

  1374     eventListenerOrder.push('on attach');

  1375     onAttach.resolve();

  1376   });

  1377   sidebar.on('ready', function() {

  1378     assert.equal(this, sidebar, '`this` is correct in on ready');

  1379     eventListenerOrder.push('on ready');

  1380     onReady.resolve();

  1381   });

  1382   sidebar.on('hide', function() {

  1383     assert.equal(this, sidebar, '`this` is correct in on hide');

  1384     eventListenerOrder.push('on hide');

  1385     onHide.resolve();

  1386   });

  1388   all([constructorOnShow.promise,

  1389       constructorOnAttach.promise,

  1390       constructorOnReady.promise,

  1391       constructorOnHide.promise,

  1392       onceShow.promise,

  1393       onceAttach.promise,

  1394       onceReady.promise,

  1395       onceHide.promise,

  1396       onShow.promise,

  1397       onAttach.promise,

  1398       onReady.promise,

  1399       onHide.promise]).then(function() {

  1400         assert.equal(eventListenerOrder.join(), [

  1401             'onAttach',

  1402             'once attach',

  1403             'on attach',

  1404             'onReady',

  1405             'once ready',

  1406             'on ready',

  1407             'onShow',

  1408             'once show',

  1409             'on show',

  1410             'onHide',

  1411             'once hide',

  1412             'on hide'

  1413           ].join(), 'the event order was correct');

  1414         sidebar.destroy();

  1415       }).then(done, assert.fail);

  1417   sidebar.show();

  1418 }

  1420 // For more information see Bug 920780

  1421 exports.testAttachDoesNotEmitWhenShown = function(assert, done) {

  1422   const { Sidebar } = require('sdk/ui/sidebar');

  1423   let testName = 'testSidebarLeakCheckUnloadAfterAttach';

  1424   let count = 0;

  1426   let sidebar = Sidebar({

  1427     id: testName,

  1428     title: testName,

  1429     url: 'data:text/html;charset=utf-8,'+testName,

  1430     onAttach: function() {

  1431       if (count > 2) {

  1432         assert.fail('sidebar was attached again..');

  1433       }

  1434       else {

  1435         assert.pass('sidebar was attached ' + count + ' time(s)');

  1436       }

  1438       if (++count == 1) {

  1439         setImmediate(function() {

  1440           let shownFired = 0;

  1441           let onShow = () => shownFired++;

  1442           sidebar.on('show', onShow);

  1444           sidebar.show()

  1445           .then(() => assert.equal(shownFired, 0, 'shown should not be fired again when already showing from after attach'))

  1446           .then(sidebar.hide.bind(sidebar))

  1447           .then(sidebar.show.bind(sidebar))

  1448           .then(() => assert.equal(shownFired, 1, 'shown was emitted when `show` called after being hidden'))

  1449           .then(sidebar.show.bind(sidebar))

  1450           .then(() => {

  1451             assert.equal(shownFired, 1, 'shown was not emitted again if already being shown');

  1452             sidebar.off('show', onShow);

  1453             sidebar.destroy();

  1454           }).catch(assert.fail).then(done);

  1455         });

  1456       }

  1457     }

  1458   });

  1460   sidebar.show();

  1461 }

  1463 // If the module doesn't support the app we're being run in, require() will

  1464 // throw.  In that case, remove all tests above from exports, and add one dummy

  1465 // test that passes.

  1466 try {

  1467   require('sdk/ui/sidebar');

  1468 }

  1469 catch (err) {

  1470   if (!/^Unsupported Application/.test(err.message))

  1471     throw err;

  1473   module.exports = {

  1474     'test Unsupported Application': assert => assert.pass(err.message)

  1475   }

  1476 }

  1478 require('sdk/test').run(exports);

The Tor Browser / file revision

addon-sdk/source/test/test-ui-sidebar.js@129ffea94266

addon-sdk/source/test/test-ui-sidebar.js