The Tor Browser: addon-sdk/source/test/test-tab-events.js@6474c204b198 (annotated)

addon-sdk/source/test/test-tab-events.js@6474c204b198 (annotated)

addon-sdk/source/test/test-tab-events.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 "use strict";
 const { Loader } = require("sdk/test/loader");
 const utils = require("sdk/tabs/utils");
 const { open, close } = require("sdk/window/helpers");
 const { getMostRecentBrowserWindow } = require("sdk/window/utils");
 const { events } = require("sdk/tab/events");
 const { on, off } = require("sdk/event/core");
 const { resolve, defer } = require("sdk/core/promise");
 let isFennec = require("sdk/system/xul-app").is("Fennec");
 function test(options) {
   return function(assert, done) {
     let tabEvents = [];
     let tabs = [];
     let { promise, resolve: resolveP } = defer();
     let win = isFennec ? resolve(getMostRecentBrowserWindow()) :
       open(null, {
         features: { private: true, toolbar:true, chrome: true }
       });
     let window = null;
     // Firefox events are fired sync; Fennec events async
     // this normalizes the tests
     function handler (event) {
       tabEvents.push(event);
       runIfReady();
     }
     function runIfReady () {
       let releventEvents = getRelatedEvents(tabEvents, tabs);
       if (options.readyWhen(releventEvents))
         options.end({
           tabs: tabs,
           events: releventEvents,
           assert: assert,
           done: resolveP
         });
     }
     win.then(function(w) {
       window = w;
       on(events, "data", handler);
       options.start({ tabs: tabs, window: window });
       // Execute here for synchronous FF events, as the handlers
       // were called before tabs were pushed to `tabs`
       runIfReady();
       return promise;
     }).then(function() {
       off(events, "data", handler);
       return isFennec ? null : close(window);
     }).then(done, assert.fail);
   };
 }
 // Just making sure that tab events work for already opened tabs not only
 // for new windows.
 exports["test current window"] = test({
   readyWhen: events => events.length === 3,
   start: ({ tabs, window }) => {
     let tab = utils.openTab(window, 'data:text/plain,open');
     tabs.push(tab);
     utils.closeTab(tab);
   },
   end: ({ tabs, events, assert, done }) => {
     let [open, select, close] = events;
     let tab = tabs[0];
     assert.equal(open.type, "TabOpen");
     assert.equal(open.target, tab);
     assert.equal(select.type, "TabSelect");
     assert.equal(select.target, tab);
     assert.equal(close.type, "TabClose");
     assert.equal(close.target, tab);
     done();
   }
 });
 exports["test open"] = test({
   readyWhen: events => events.length === 2,
   start: ({ tabs, window }) => {
     tabs.push(utils.openTab(window, 'data:text/plain,open'));
   },
   end: ({ tabs, events, assert, done }) => {
     let [open, select] = events;
     let tab = tabs[0];
     assert.equal(open.type, "TabOpen");
     assert.equal(open.target, tab);
     assert.equal(select.type, "TabSelect");
     assert.equal(select.target, tab);
     done();
   }
 });
 exports["test open -> close"] = test({
   readyWhen: events => events.length === 3,
   start: ({ tabs, window }) => {
     // First tab is useless we just open it so that closing second tab won't
     // close window on some platforms.
     utils.openTab(window, 'data:text/plain,ignore');
     let tab = utils.openTab(window, 'data:text/plain,open-close');
     tabs.push(tab);
     utils.closeTab(tab);
   },
   end: ({ tabs, events, assert, done }) => {
     let [open, select, close] = events;
     let tab = tabs[0];
     assert.equal(open.type, "TabOpen");
     assert.equal(open.target, tab);
     assert.equal(select.type, "TabSelect");
     assert.equal(select.target, tab);
     assert.equal(close.type, "TabClose");
     assert.equal(close.target, tab);
     done();
   }
 });
 exports["test open -> open -> select"] = test({
   readyWhen: events => events.length === 5,
   start: ({tabs, window}) => {
     tabs.push(utils.openTab(window, 'data:text/plain,Tab-1'));
     tabs.push(utils.openTab(window, 'data:text/plain,Tab-2'));
     utils.activateTab(tabs[0], window);
   },
   end: ({ tabs, events, assert, done }) => {
     let [ tab1, tab2 ] = tabs;
     let tab1Events = 0;
     getRelatedEvents(events, tab1).map(event => {
       tab1Events++;
       if (tab1Events === 1)
         assert.equal(event.type, "TabOpen", "first tab opened");
       else
         assert.equal(event.type, "TabSelect", "first tab selected");
       assert.equal(event.target, tab1);
     });
     assert.equal(tab1Events, 3, "first tab has 3 events");
     let tab2Opened;
     getRelatedEvents(events, tab2).map(event => {
       if (!tab2Opened)
         assert.equal(event.type, "TabOpen", "second tab opened");
       else
         assert.equal(event.type, "TabSelect", "second tab selected");
       tab2Opened = true;
       assert.equal(event.target, tab2);
     });
     done();
   }
 });
 exports["test open -> pin -> unpin"] = test({
   readyWhen: events => events.length === (isFennec ? 2 : 5),
   start: ({ tabs, window }) => {
     tabs.push(utils.openTab(window, 'data:text/plain,pin-unpin'));
     utils.pin(tabs[0]);
     utils.unpin(tabs[0]);
   },
   end: ({ tabs, events, assert, done }) => {
     let [open, select, move, pin, unpin] = events;
     let tab = tabs[0];
     assert.equal(open.type, "TabOpen");
     assert.equal(open.target, tab);
     assert.equal(select.type, "TabSelect");
     assert.equal(select.target, tab);
     if (isFennec) {
       assert.pass("Tab pin / unpin is not supported by Fennec");
     }
     else {
       assert.equal(move.type, "TabMove");
       assert.equal(move.target, tab);
       assert.equal(pin.type, "TabPinned");
       assert.equal(pin.target, tab);
       assert.equal(unpin.type, "TabUnpinned");
       assert.equal(unpin.target, tab);
     }
     done();
   }
 });
 exports["test open -> open -> move "] = test({
   readyWhen: events => events.length === (isFennec ? 4 : 5),
   start: ({tabs, window}) => {
     tabs.push(utils.openTab(window, 'data:text/plain,Tab-1'));
     tabs.push(utils.openTab(window, 'data:text/plain,Tab-2'));
     utils.move(tabs[0], 2);
   },
   end: ({ tabs, events, assert, done }) => {
     let [ tab1, tab2 ] = tabs;
     let tab1Events = 0;
     getRelatedEvents(events, tab1).map(event => {
       tab1Events++;
       if (tab1Events === 1)
         assert.equal(event.type, "TabOpen", "first tab opened");
       else if (tab1Events === 2)
         assert.equal(event.type, "TabSelect", "first tab selected");
       else if (tab1Events === 3 && isFennec)
         assert.equal(event.type, "TabMove", "first tab moved");
       assert.equal(event.target, tab1);
     });
     assert.equal(tab1Events, isFennec ? 2 : 3,
       "correct number of events for first tab");
     let tab2Events = 0;
     getRelatedEvents(events, tab2).map(event => {
       tab2Events++;
       if (tab2Events === 1)
         assert.equal(event.type, "TabOpen", "second tab opened");
       else
         assert.equal(event.type, "TabSelect", "second tab selected");
       assert.equal(event.target, tab2);
     });
     done();
   }
 });
 function getRelatedEvents (events, tabs) {
   return events.filter(({target}) => ~([].concat(tabs)).indexOf(target));
 }
 require("sdk/test").run(exports);