The Tor Browser: comparison addon-sdk/source/test/test-tab-events.js

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

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

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:5fcc050eae61
+/* 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);